@vitejs/devtools 0.0.0-alpha.8 → 0.1.0

package/dist/{dist-BuuUhVT5.js → dist-3NIYLDlS.js}

@@ -1,14 +1,14 @@
-//#region ../../node_modules/.pnpm/@vue+shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.30/node_modules/@vue/shared/dist/shared.esm-bundler.js
 /**
-* @vue/shared v3.5.22
+* @vue/shared v3.5.30
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
 /* @__NO_SIDE_EFFECTS__ */
 function makeMap(str) {
-	const map$1 = /* @__PURE__ */ Object.create(null);
-	for (const key of str.split(",")) map$1[key] = 1;
-	return (val) => val in map$1;
+	const map = /* @__PURE__ */ Object.create(null);
+	for (const key of str.split(",")) map[key] = 1;
+	return (val) => val in map;
 }
 const EMPTY_OBJ = !!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
 const EMPTY_ARR = !!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
@@ -22,10 +22,11 @@ const remove = (arr, el) => {
 	if (i > -1) arr.splice(i, 1);
 };
 const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
-const hasOwn$1 = (val, key) => hasOwnProperty$1.call(val, key);
+const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
 const isArray = Array.isArray;
 const isMap = (val) => toTypeString(val) === "[object Map]";
 const isSet = (val) => toTypeString(val) === "[object Set]";
+const isDate = (val) => toTypeString(val) === "[object Date]";
 const isFunction = (val) => typeof val === "function";
 const isString = (val) => typeof val === "string";
 const isSymbol = (val) => typeof val === "symbol";
@@ -128,10 +129,40 @@ const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
 const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
 const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
 const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
-const isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
+specialBooleanAttrs + "";
 function includeBooleanAttr(value) {
 	return !!value || value === "";
 }
+function looseCompareArrays(a, b) {
+	if (a.length !== b.length) return false;
+	let equal = true;
+	for (let i = 0; equal && i < a.length; i++) equal = looseEqual(a[i], b[i]);
+	return equal;
+}
+function looseEqual(a, b) {
+	if (a === b) return true;
+	let aValidType = isDate(a);
+	let bValidType = isDate(b);
+	if (aValidType || bValidType) return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+	aValidType = isSymbol(a);
+	bValidType = isSymbol(b);
+	if (aValidType || bValidType) return a === b;
+	aValidType = isArray(a);
+	bValidType = isArray(b);
+	if (aValidType || bValidType) return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+	aValidType = isObject$1(a);
+	bValidType = isObject$1(b);
+	if (aValidType || bValidType) {
+		if (!aValidType || !bValidType) return false;
+		if (Object.keys(a).length !== Object.keys(b).length) return false;
+		for (const key in a) {
+			const aHasKey = a.hasOwnProperty(key);
+			const bHasKey = b.hasOwnProperty(key);
+			if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) return false;
+		}
+	}
+	return String(a) === String(b);
+}
 const isRef$1 = (val) => {
 	return !!(val && val["__v_isRef"] === true);
 };
@@ -153,9 +184,13 @@ const stringifySymbol = (v, i = "") => {
 	var _a;
 	return isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v;
 };
-
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.22/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+reactivity@3.5.30/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+/**
+* @vue/reactivity v3.5.30
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 function warn$2(msg, ...args) {
 	console.warn(`[Vue warn] ${msg}`, ...args);
 }
@@ -180,6 +215,7 @@ var EffectScope = class {
 		*/
 		this.cleanups = [];
 		this._isPaused = false;
+		this.__v_skip = true;
 		this.parent = activeEffectScope;
 		if (!detached && activeEffectScope) this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
 	}
@@ -434,24 +470,24 @@ function isDirty(sub) {
 	if (sub._dirty) return true;
 	return false;
 }
-function refreshComputed(computed$2) {
-	if (computed$2.flags & 4 && !(computed$2.flags & 16)) return;
-	computed$2.flags &= -17;
-	if (computed$2.globalVersion === globalVersion) return;
-	computed$2.globalVersion = globalVersion;
-	if (!computed$2.isSSR && computed$2.flags & 128 && (!computed$2.deps && !computed$2._dirty || !isDirty(computed$2))) return;
-	computed$2.flags |= 2;
-	const dep = computed$2.dep;
+function refreshComputed(computed) {
+	if (computed.flags & 4 && !(computed.flags & 16)) return;
+	computed.flags &= -17;
+	if (computed.globalVersion === globalVersion) return;
+	computed.globalVersion = globalVersion;
+	if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) return;
+	computed.flags |= 2;
+	const dep = computed.dep;
 	const prevSub = activeSub;
 	const prevShouldTrack = shouldTrack;
-	activeSub = computed$2;
+	activeSub = computed;
 	shouldTrack = true;
 	try {
-		prepareDeps(computed$2);
-		const value = computed$2.fn(computed$2._value);
-		if (dep.version === 0 || hasChanged(value, computed$2._value)) {
-			computed$2.flags |= 128;
-			computed$2._value = value;
+		prepareDeps(computed);
+		const value = computed.fn(computed._value);
+		if (dep.version === 0 || hasChanged(value, computed._value)) {
+			computed.flags |= 128;
+			computed._value = value;
 			dep.version++;
 		}
 	} catch (err) {
@@ -460,8 +496,8 @@ function refreshComputed(computed$2) {
 	} finally {
 		activeSub = prevSub;
 		shouldTrack = prevShouldTrack;
-		cleanupDeps(computed$2);
-		computed$2.flags &= -3;
+		cleanupDeps(computed);
+		computed.flags &= -3;
 	}
 }
 function removeSub(link, soft = false) {
@@ -528,8 +564,8 @@ var Link = class {
 	}
 };
 var Dep = class {
-	constructor(computed$2) {
-		this.computed = computed$2;
+	constructor(computed) {
+		this.computed = computed;
 		this.version = 0;
 		/**
 		* Link between this dep and the current active effect
@@ -602,10 +638,10 @@ var Dep = class {
 function addSub(link) {
 	link.dep.sc++;
 	if (link.sub.flags & 4) {
-		const computed$2 = link.dep.computed;
-		if (computed$2 && !link.dep.subs) {
-			computed$2.flags |= 20;
-			for (let l = computed$2.deps; l; l = l.nextDep) addSub(l);
+		const computed = link.dep.computed;
+		if (computed && !link.dep.subs) {
+			computed.flags |= 20;
+			for (let l = computed.deps; l; l = l.nextDep) addSub(l);
 		}
 		const currentTail = link.dep.subs;
 		if (currentTail !== link) {
@@ -617,9 +653,9 @@ function addSub(link) {
 	}
 }
 const targetMap = /* @__PURE__ */ new WeakMap();
-const ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Object iterate" : "");
-const MAP_KEY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Map keys iterate" : "");
-const ARRAY_ITERATE_KEY = Symbol(!!(process.env.NODE_ENV !== "production") ? "Array iterate" : "");
+const ITERATE_KEY = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "Object iterate" : "");
+const MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "Map keys iterate" : "");
+const ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "Array iterate" : "");
 function track(target, type, key) {
 	if (shouldTrack && activeSub) {
 		let depsMap = targetMap.get(target);
@@ -694,26 +730,30 @@ function getDepFromReactive(object, key) {
 	return depMap && depMap.get(key);
 }
 function reactiveReadArray(array) {
-	const raw = toRaw(array);
+	const raw = /* @__PURE__ */ toRaw(array);
 	if (raw === array) return raw;
 	track(raw, "iterate", ARRAY_ITERATE_KEY);
-	return isShallow(array) ? raw : raw.map(toReactive);
+	return /* @__PURE__ */ isShallow(array) ? raw : raw.map(toReactive);
 }
 function shallowReadArray(arr) {
-	track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+	track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
 	return arr;
 }
+function toWrapped(target, item) {
+	if (/* @__PURE__ */ isReadonly(target)) return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
+	return toReactive(item);
+}
 const arrayInstrumentations = {
 	__proto__: null,
 	[Symbol.iterator]() {
-		return iterator(this, Symbol.iterator, toReactive);
+		return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
 	},
 	concat(...args) {
 		return reactiveReadArray(this).concat(...args.map((x) => isArray(x) ? reactiveReadArray(x) : x));
 	},
 	entries() {
 		return iterator(this, "entries", (value) => {
-			value[1] = toReactive(value[1]);
+			value[1] = toWrapped(this, value[1]);
 			return value;
 		});
 	},
@@ -721,16 +761,16 @@ const arrayInstrumentations = {
 		return apply(this, "every", fn, thisArg, void 0, arguments);
 	},
 	filter(fn, thisArg) {
-		return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
+		return apply(this, "filter", fn, thisArg, (v) => v.map((item) => toWrapped(this, item)), arguments);
 	},
 	find(fn, thisArg) {
-		return apply(this, "find", fn, thisArg, toReactive, arguments);
+		return apply(this, "find", fn, thisArg, (item) => toWrapped(this, item), arguments);
 	},
 	findIndex(fn, thisArg) {
 		return apply(this, "findIndex", fn, thisArg, void 0, arguments);
 	},
 	findLast(fn, thisArg) {
-		return apply(this, "findLast", fn, thisArg, toReactive, arguments);
+		return apply(this, "findLast", fn, thisArg, (item) => toWrapped(this, item), arguments);
 	},
 	findLastIndex(fn, thisArg) {
 		return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
@@ -787,13 +827,13 @@ const arrayInstrumentations = {
 		return noTracking(this, "unshift", args);
 	},
 	values() {
-		return iterator(this, "values", toReactive);
+		return iterator(this, "values", (item) => toWrapped(this, item));
 	}
 };
-function iterator(self$1, method, wrapValue) {
-	const arr = shallowReadArray(self$1);
+function iterator(self, method, wrapValue) {
+	const arr = shallowReadArray(self);
 	const iter = arr[method]();
-	if (arr !== self$1 && !isShallow(self$1)) {
+	if (arr !== self && !/* @__PURE__ */ isShallow(self)) {
 		iter._next = iter.next;
 		iter.next = () => {
 			const result = iter._next();
@@ -804,53 +844,62 @@ function iterator(self$1, method, wrapValue) {
 	return iter;
 }
 const arrayProto = Array.prototype;
-function apply(self$1, method, fn, thisArg, wrappedRetFn, args) {
-	const arr = shallowReadArray(self$1);
-	const needsWrap = arr !== self$1 && !isShallow(self$1);
+function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+	const arr = shallowReadArray(self);
+	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
 	const methodFn = arr[method];
 	if (methodFn !== arrayProto[method]) {
-		const result2 = methodFn.apply(self$1, args);
+		const result2 = methodFn.apply(self, args);
 		return needsWrap ? toReactive(result2) : result2;
 	}
 	let wrappedFn = fn;
-	if (arr !== self$1) {
+	if (arr !== self) {
 		if (needsWrap) wrappedFn = function(item, index) {
-			return fn.call(this, toReactive(item), index, self$1);
+			return fn.call(this, toWrapped(self, item), index, self);
 		};
 		else if (fn.length > 2) wrappedFn = function(item, index) {
-			return fn.call(this, item, index, self$1);
+			return fn.call(this, item, index, self);
 		};
 	}
 	const result = methodFn.call(arr, wrappedFn, thisArg);
 	return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
 }
-function reduce(self$1, method, fn, args) {
-	const arr = shallowReadArray(self$1);
+function reduce(self, method, fn, args) {
+	const arr = shallowReadArray(self);
+	const needsWrap = arr !== self && !/* @__PURE__ */ isShallow(self);
 	let wrappedFn = fn;
-	if (arr !== self$1) {
-		if (!isShallow(self$1)) wrappedFn = function(acc, item, index) {
-			return fn.call(this, acc, toReactive(item), index, self$1);
-		};
-		else if (fn.length > 3) wrappedFn = function(acc, item, index) {
-			return fn.call(this, acc, item, index, self$1);
+	let wrapInitialAccumulator = false;
+	if (arr !== self) {
+		if (needsWrap) {
+			wrapInitialAccumulator = args.length === 0;
+			wrappedFn = function(acc, item, index) {
+				if (wrapInitialAccumulator) {
+					wrapInitialAccumulator = false;
+					acc = toWrapped(self, acc);
+				}
+				return fn.call(this, acc, toWrapped(self, item), index, self);
+			};
+		} else if (fn.length > 3) wrappedFn = function(acc, item, index) {
+			return fn.call(this, acc, item, index, self);
 		};
 	}
-	return arr[method](wrappedFn, ...args);
+	const result = arr[method](wrappedFn, ...args);
+	return wrapInitialAccumulator ? toWrapped(self, result) : result;
 }
-function searchProxy(self$1, method, args) {
-	const arr = toRaw(self$1);
+function searchProxy(self, method, args) {
+	const arr = /* @__PURE__ */ toRaw(self);
 	track(arr, "iterate", ARRAY_ITERATE_KEY);
 	const res = arr[method](...args);
-	if ((res === -1 || res === false) && isProxy(args[0])) {
-		args[0] = toRaw(args[0]);
+	if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) {
+		args[0] = /* @__PURE__ */ toRaw(args[0]);
 		return arr[method](...args);
 	}
 	return res;
 }
-function noTracking(self$1, method, args = []) {
+function noTracking(self, method, args = []) {
 	pauseTracking();
 	startBatch();
-	const res = toRaw(self$1)[method].apply(self$1, args);
+	const res = (/* @__PURE__ */ toRaw(self))[method].apply(self, args);
 	endBatch();
 	resetTracking();
 	return res;
@@ -859,7 +908,7 @@ 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));
 function hasOwnProperty(key) {
 	if (!isSymbol(key)) key = String(key);
-	const obj = toRaw(this);
+	const obj = /* @__PURE__ */ toRaw(this);
 	track(obj, "has", key);
 	return obj.hasOwnProperty(key);
 }
@@ -884,15 +933,15 @@ var BaseReactiveHandler = class {
 			if (targetIsArray && (fn = arrayInstrumentations[key])) return fn;
 			if (key === "hasOwnProperty") return hasOwnProperty;
 		}
-		const res = Reflect.get(target, key, isRef(target) ? target : receiver);
+		const res = Reflect.get(target, key, /* @__PURE__ */ isRef(target) ? target : receiver);
 		if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
 		if (!isReadonly2) track(target, "get", key);
 		if (isShallow2) return res;
-		if (isRef(res)) {
+		if (/* @__PURE__ */ isRef(res)) {
 			const value = targetIsArray && isIntegerKey(key) ? res : res.value;
-			return isReadonly2 && isObject$1(value) ? readonly(value) : value;
+			return isReadonly2 && isObject$1(value) ? /* @__PURE__ */ readonly(value) : value;
 		}
-		if (isObject$1(res)) return isReadonly2 ? readonly(res) : reactive(res);
+		if (isObject$1(res)) return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
 		return res;
 	}
 };
@@ -902,13 +951,14 @@ var MutableReactiveHandler = class extends BaseReactiveHandler {
 	}
 	set(target, key, value, receiver) {
 		let oldValue = target[key];
+		const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
 		if (!this._isShallow) {
-			const isOldValueReadonly = isReadonly(oldValue);
-			if (!isShallow(value) && !isReadonly(value)) {
-				oldValue = toRaw(oldValue);
-				value = toRaw(value);
+			const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue);
+			if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
+				oldValue = /* @__PURE__ */ toRaw(oldValue);
+				value = /* @__PURE__ */ toRaw(value);
 			}
-			if (!isArray(target) && isRef(oldValue) && !isRef(value)) if (isOldValueReadonly) {
+			if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) if (isOldValueReadonly) {
 				if (!!(process.env.NODE_ENV !== "production")) warn$2(`Set operation on key "${String(key)}" failed: target is readonly.`, target[key]);
 				return true;
 			} else {
@@ -916,16 +966,16 @@ var MutableReactiveHandler = class extends BaseReactiveHandler {
 				return true;
 			}
 		}
-		const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key);
-		const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
-		if (target === toRaw(receiver)) {
+		const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
+		const result = Reflect.set(target, key, value, /* @__PURE__ */ isRef(target) ? target : receiver);
+		if (target === /* @__PURE__ */ toRaw(receiver)) {
 			if (!hadKey) trigger(target, "add", key, value);
 			else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
 		}
 		return result;
 	}
 	deleteProperty(target, key) {
-		const hadKey = hasOwn$1(target, key);
+		const hadKey = hasOwn(target, key);
 		const oldValue = target[key];
 		const result = Reflect.deleteProperty(target, key);
 		if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
@@ -963,65 +1013,60 @@ const getProto = (v) => Reflect.getPrototypeOf(v);
 function createIterableMethod(method, isReadonly2, isShallow2) {
 	return function(...args) {
 		const target = this["__v_raw"];
-		const rawTarget = toRaw(target);
+		const rawTarget = /* @__PURE__ */ toRaw(target);
 		const targetIsMap = isMap(rawTarget);
 		const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
 		const isKeyOnly = method === "keys" && targetIsMap;
 		const innerIterator = target[method](...args);
 		const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
 		!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
-		return {
-			next() {
-				const { value, done } = innerIterator.next();
-				return done ? {
-					value,
-					done
-				} : {
-					value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
-					done
-				};
-			},
-			[Symbol.iterator]() {
-				return this;
-			}
-		};
+		return extend(Object.create(innerIterator), { next() {
+			const { value, done } = innerIterator.next();
+			return done ? {
+				value,
+				done
+			} : {
+				value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+				done
+			};
+		} });
 	};
 }
 function createReadonlyMethod(type) {
 	return function(...args) {
 		if (!!(process.env.NODE_ENV !== "production")) {
 			const key = args[0] ? `on key "${args[0]}" ` : ``;
-			warn$2(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+			warn$2(`${capitalize(type)} operation ${key}failed: target is readonly.`, /* @__PURE__ */ toRaw(this));
 		}
 		return type === "delete" ? false : type === "clear" ? void 0 : this;
 	};
 }
-function createInstrumentations(readonly$1, shallow) {
+function createInstrumentations(readonly, shallow) {
 	const instrumentations = {
 		get(key) {
 			const target = this["__v_raw"];
-			const rawTarget = toRaw(target);
-			const rawKey = toRaw(key);
-			if (!readonly$1) {
+			const rawTarget = /* @__PURE__ */ toRaw(target);
+			const rawKey = /* @__PURE__ */ toRaw(key);
+			if (!readonly) {
 				if (hasChanged(key, rawKey)) track(rawTarget, "get", key);
 				track(rawTarget, "get", rawKey);
 			}
 			const { has } = getProto(rawTarget);
-			const wrap = shallow ? toShallow : readonly$1 ? toReadonly : toReactive;
+			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
 			if (has.call(rawTarget, key)) return wrap(target.get(key));
 			else if (has.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
 			else if (target !== rawTarget) target.get(key);
 		},
 		get size() {
 			const target = this["__v_raw"];
-			!readonly$1 && track(toRaw(target), "iterate", ITERATE_KEY);
+			!readonly && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY);
 			return target.size;
 		},
 		has(key) {
 			const target = this["__v_raw"];
-			const rawTarget = toRaw(target);
-			const rawKey = toRaw(key);
-			if (!readonly$1) {
+			const rawTarget = /* @__PURE__ */ toRaw(target);
+			const rawKey = /* @__PURE__ */ toRaw(key);
+			if (!readonly) {
 				if (hasChanged(key, rawKey)) track(rawTarget, "has", key);
 				track(rawTarget, "has", rawKey);
 			}
@@ -1030,36 +1075,38 @@ function createInstrumentations(readonly$1, shallow) {
 		forEach(callback, thisArg) {
 			const observed = this;
 			const target = observed["__v_raw"];
-			const rawTarget = toRaw(target);
-			const wrap = shallow ? toShallow : readonly$1 ? toReadonly : toReactive;
-			!readonly$1 && track(rawTarget, "iterate", ITERATE_KEY);
+			const rawTarget = /* @__PURE__ */ toRaw(target);
+			const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+			!readonly && track(rawTarget, "iterate", ITERATE_KEY);
 			return target.forEach((value, key) => {
 				return callback.call(thisArg, wrap(value), wrap(key), observed);
 			});
 		}
 	};
-	extend(instrumentations, readonly$1 ? {
+	extend(instrumentations, readonly ? {
 		add: createReadonlyMethod("add"),
 		set: createReadonlyMethod("set"),
 		delete: createReadonlyMethod("delete"),
 		clear: createReadonlyMethod("clear")
 	} : {
 		add(value) {
-			if (!shallow && !isShallow(value) && !isReadonly(value)) value = toRaw(value);
-			const target = toRaw(this);
-			if (!getProto(target).has.call(target, value)) {
-				target.add(value);
-				trigger(target, "add", value, value);
+			const target = /* @__PURE__ */ toRaw(this);
+			const proto = getProto(target);
+			const rawValue = /* @__PURE__ */ toRaw(value);
+			const valueToAdd = !shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value) ? rawValue : value;
+			if (!(proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue))) {
+				target.add(valueToAdd);
+				trigger(target, "add", valueToAdd, valueToAdd);
 			}
 			return this;
 		},
 		set(key, value) {
-			if (!shallow && !isShallow(value) && !isReadonly(value)) value = toRaw(value);
-			const target = toRaw(this);
+			if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value);
+			const target = /* @__PURE__ */ toRaw(this);
 			const { has, get } = getProto(target);
 			let hadKey = has.call(target, key);
 			if (!hadKey) {
-				key = toRaw(key);
+				key = /* @__PURE__ */ toRaw(key);
 				hadKey = has.call(target, key);
 			} else if (!!(process.env.NODE_ENV !== "production")) checkIdentityKeys(target, has, key);
 			const oldValue = get.call(target, key);
@@ -1069,11 +1116,11 @@ function createInstrumentations(readonly$1, shallow) {
 			return this;
 		},
 		delete(key) {
-			const target = toRaw(this);
+			const target = /* @__PURE__ */ toRaw(this);
 			const { has, get } = getProto(target);
 			let hadKey = has.call(target, key);
 			if (!hadKey) {
-				key = toRaw(key);
+				key = /* @__PURE__ */ toRaw(key);
 				hadKey = has.call(target, key);
 			} else if (!!(process.env.NODE_ENV !== "production")) checkIdentityKeys(target, has, key);
 			const oldValue = get ? get.call(target, key) : void 0;
@@ -1082,7 +1129,7 @@ function createInstrumentations(readonly$1, shallow) {
 			return result;
 		},
 		clear() {
-			const target = toRaw(this);
+			const target = /* @__PURE__ */ toRaw(this);
 			const hadItems = target.size !== 0;
 			const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
 			const result = target.clear();
@@ -1096,7 +1143,7 @@ function createInstrumentations(readonly$1, shallow) {
 		"entries",
 		Symbol.iterator
 	].forEach((method) => {
-		instrumentations[method] = createIterableMethod(method, readonly$1, shallow);
+		instrumentations[method] = createIterableMethod(method, readonly, shallow);
 	});
 	return instrumentations;
 }
@@ -1106,7 +1153,7 @@ function createInstrumentationGetter(isReadonly2, shallow) {
 		if (key === "__v_isReactive") return !isReadonly2;
 		else if (key === "__v_isReadonly") return isReadonly2;
 		else if (key === "__v_raw") return target;
-		return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
+		return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
 	};
 }
 const mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
@@ -1114,7 +1161,7 @@ const shallowCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGe
 const readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
 const shallowReadonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, true) };
 function checkIdentityKeys(target, has, key) {
-	const rawKey = toRaw(key);
+	const rawKey = /* @__PURE__ */ toRaw(key);
 	if (rawKey !== key && has.call(target, rawKey)) {
 		const type = toRawType(target);
 		warn$2(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
@@ -1138,16 +1185,20 @@ function targetTypeMap(rawType) {
 function getTargetType(value) {
 	return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
 }
+/* @__NO_SIDE_EFFECTS__ */
 function reactive(target) {
-	if (isReadonly(target)) return target;
+	if (/* @__PURE__ */ isReadonly(target)) return target;
 	return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function shallowReactive(target) {
 	return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function readonly(target) {
 	return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function shallowReadonly(target) {
 	return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
 }
@@ -1165,40 +1216,48 @@ function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandl
 	proxyMap.set(target, proxy);
 	return proxy;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function isReactive(value) {
-	if (isReadonly(value)) return isReactive(value["__v_raw"]);
+	if (/* @__PURE__ */ isReadonly(value)) return /* @__PURE__ */ isReactive(value["__v_raw"]);
 	return !!(value && value["__v_isReactive"]);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function isReadonly(value) {
 	return !!(value && value["__v_isReadonly"]);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function isShallow(value) {
 	return !!(value && value["__v_isShallow"]);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function isProxy(value) {
 	return value ? !!value["__v_raw"] : false;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function toRaw(observed) {
 	const raw = observed && observed["__v_raw"];
-	return raw ? toRaw(raw) : observed;
+	return raw ? /* @__PURE__ */ toRaw(raw) : observed;
 }
 function markRaw(value) {
-	if (!hasOwn$1(value, "__v_skip") && Object.isExtensible(value)) def(value, "__v_skip", true);
+	if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) def(value, "__v_skip", true);
 	return value;
 }
-const toReactive = (value) => isObject$1(value) ? reactive(value) : value;
-const toReadonly = (value) => isObject$1(value) ? readonly(value) : value;
+const toReactive = (value) => isObject$1(value) ? /* @__PURE__ */ reactive(value) : value;
+const toReadonly = (value) => isObject$1(value) ? /* @__PURE__ */ readonly(value) : value;
+/* @__NO_SIDE_EFFECTS__ */
 function isRef(r) {
 	return r ? r["__v_isRef"] === true : false;
 }
+/* @__NO_SIDE_EFFECTS__ */
 function ref(value) {
-	return createRef$1(value, false);
+	return createRef(value, false);
 }
+/* @__NO_SIDE_EFFECTS__ */
 function shallowRef(value) {
-	return createRef$1(value, true);
+	return createRef(value, true);
 }
-function createRef$1(rawValue, shallow) {
-	if (isRef(rawValue)) return rawValue;
+function createRef(rawValue, shallow) {
+	if (/* @__PURE__ */ isRef(rawValue)) return rawValue;
 	return new RefImpl(rawValue, shallow);
 }
 var RefImpl = class {
@@ -1206,7 +1265,7 @@ var RefImpl = class {
 		this.dep = new Dep();
 		this["__v_isRef"] = true;
 		this["__v_isShallow"] = false;
-		this._rawValue = isShallow2 ? value : toRaw(value);
+		this._rawValue = isShallow2 ? value : /* @__PURE__ */ toRaw(value);
 		this._value = isShallow2 ? value : toReactive(value);
 		this["__v_isShallow"] = isShallow2;
 	}
@@ -1221,8 +1280,8 @@ var RefImpl = class {
 	}
 	set value(newValue) {
 		const oldValue = this._rawValue;
-		const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
-		newValue = useDirectValue ? newValue : toRaw(newValue);
+		const useDirectValue = this["__v_isShallow"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue);
+		newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue);
 		if (hasChanged(newValue, oldValue)) {
 			this._rawValue = newValue;
 			this._value = useDirectValue ? newValue : toReactive(newValue);
@@ -1238,7 +1297,7 @@ var RefImpl = class {
 	}
 };
 function unref(ref2) {
-	return isRef(ref2) ? ref2.value : ref2;
+	return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2;
 }
 function toValue(source) {
 	return isFunction(source) ? source() : unref(source);
@@ -1247,14 +1306,14 @@ const shallowUnwrapHandlers = {
 	get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
 	set: (target, key, value, receiver) => {
 		const oldValue = target[key];
-		if (isRef(oldValue) && !isRef(value)) {
+		if (/* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) {
 			oldValue.value = value;
 			return true;
 		} else return Reflect.set(target, key, value, receiver);
 	}
 };
 function proxyRefs(objectWithRefs) {
-	return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
+	return /* @__PURE__ */ isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
 }
 var CustomRefImpl = class {
 	constructor(factory) {
@@ -1275,8 +1334,9 @@ var CustomRefImpl = class {
 function customRef(factory) {
 	return new CustomRefImpl(factory);
 }
-function toRefs$1(object) {
-	if (!!(process.env.NODE_ENV !== "production") && !isProxy(object)) warn$2(`toRefs() expects a reactive object but received a plain one.`);
+/* @__NO_SIDE_EFFECTS__ */
+function toRefs(object) {
+	if (!!(process.env.NODE_ENV !== "production") && !/* @__PURE__ */ isProxy(object)) warn$2(`toRefs() expects a reactive object but received a plain one.`);
 	const ret = isArray(object) ? new Array(object.length) : {};
 	for (const key in object) ret[key] = propertyToRef(object, key);
 	return ret;
@@ -1288,16 +1348,31 @@ var ObjectRefImpl = class {
 		this._defaultValue = _defaultValue;
 		this["__v_isRef"] = true;
 		this._value = void 0;
+		this._raw = /* @__PURE__ */ toRaw(_object);
+		let shallow = true;
+		let obj = _object;
+		if (!isArray(_object) || !isIntegerKey(String(_key))) do
+			shallow = !/* @__PURE__ */ isProxy(obj) || /* @__PURE__ */ isShallow(obj);
+		while (shallow && (obj = obj["__v_raw"]));
+		this._shallow = shallow;
 	}
 	get value() {
-		const val = this._object[this._key];
+		let val = this._object[this._key];
+		if (this._shallow) val = unref(val);
 		return this._value = val === void 0 ? this._defaultValue : val;
 	}
 	set value(newVal) {
+		if (this._shallow && /* @__PURE__ */ isRef(this._raw[this._key])) {
+			const nestedRef = this._object[this._key];
+			if (/* @__PURE__ */ isRef(nestedRef)) {
+				nestedRef.value = newVal;
+				return;
+			}
+		}
 		this._object[this._key] = newVal;
 	}
 	get dep() {
-		return getDepFromReactive(toRaw(this._object), this._key);
+		return getDepFromReactive(this._raw, this._key);
 	}
 };
 var GetterRefImpl = class {
@@ -1311,15 +1386,15 @@ var GetterRefImpl = class {
 		return this._value = this._getter();
 	}
 };
+/* @__NO_SIDE_EFFECTS__ */
 function toRef$1(source, key, defaultValue) {
-	if (isRef(source)) return source;
+	if (/* @__PURE__ */ isRef(source)) return source;
 	else if (isFunction(source)) return new GetterRefImpl(source);
 	else if (isObject$1(source) && arguments.length > 1) return propertyToRef(source, key, defaultValue);
-	else return ref(source);
+	else return /* @__PURE__ */ ref(source);
 }
 function propertyToRef(source, key, defaultValue) {
-	const val = source[key];
-	return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
+	return new ObjectRefImpl(source, key, defaultValue);
 }
 var ComputedRefImpl = class {
 	constructor(fn, setter, isSSR) {
@@ -1386,6 +1461,7 @@ var ComputedRefImpl = class {
 		else if (!!(process.env.NODE_ENV !== "production")) warn$2("Write operation failed: computed value is readonly");
 	}
 };
+/* @__NO_SIDE_EFFECTS__ */
 function computed$1(getterOrOptions, debugOptions, isSSR = false) {
 	let getter;
 	let setter;
@@ -1418,27 +1494,27 @@ function watch$1(source, cb, options = EMPTY_OBJ) {
 	};
 	const reactiveGetter = (source2) => {
 		if (deep) return source2;
-		if (isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1);
+		if (/* @__PURE__ */ isShallow(source2) || deep === false || deep === 0) return traverse(source2, 1);
 		return traverse(source2);
 	};
-	let effect$1;
+	let effect;
 	let getter;
 	let cleanup;
 	let boundCleanup;
 	let forceTrigger = false;
 	let isMultiSource = false;
-	if (isRef(source)) {
+	if (/* @__PURE__ */ isRef(source)) {
 		getter = () => source.value;
-		forceTrigger = isShallow(source);
-	} else if (isReactive(source)) {
+		forceTrigger = /* @__PURE__ */ isShallow(source);
+	} else if (/* @__PURE__ */ isReactive(source)) {
 		getter = () => reactiveGetter(source);
 		forceTrigger = true;
 	} else if (isArray(source)) {
 		isMultiSource = true;
-		forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
+		forceTrigger = source.some((s) => /* @__PURE__ */ isReactive(s) || /* @__PURE__ */ isShallow(s));
 		getter = () => source.map((s) => {
-			if (isRef(s)) return s.value;
-			else if (isReactive(s)) return reactiveGetter(s);
+			if (/* @__PURE__ */ isRef(s)) return s.value;
+			else if (/* @__PURE__ */ isReactive(s)) return reactiveGetter(s);
 			else if (isFunction(s)) return call ? call(s, 2) : s();
 			else process.env.NODE_ENV !== "production" && warnInvalidSource(s);
 		});
@@ -1453,7 +1529,7 @@ function watch$1(source, cb, options = EMPTY_OBJ) {
 			}
 		}
 		const currentEffect = activeWatcher;
-		activeWatcher = effect$1;
+		activeWatcher = effect;
 		try {
 			return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
 		} finally {
@@ -1471,8 +1547,8 @@ function watch$1(source, cb, options = EMPTY_OBJ) {
 	}
 	const scope = getCurrentScope();
 	const watchHandle = () => {
-		effect$1.stop();
-		if (scope && scope.active) remove(scope.effects, effect$1);
+		effect.stop();
+		if (scope && scope.active) remove(scope.effects, effect);
 	};
 	if (once && cb) {
 		const _cb = cb;
@@ -1483,13 +1559,13 @@ function watch$1(source, cb, options = EMPTY_OBJ) {
 	}
 	let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
 	const job = (immediateFirstRun) => {
-		if (!(effect$1.flags & 1) || !effect$1.dirty && !immediateFirstRun) return;
+		if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) return;
 		if (cb) {
-			const newValue = effect$1.run();
+			const newValue = effect.run();
 			if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
 				if (cleanup) cleanup();
 				const currentWatcher = activeWatcher;
-				activeWatcher = effect$1;
+				activeWatcher = effect;
 				try {
 					const args = [
 						newValue,
@@ -1502,30 +1578,30 @@ function watch$1(source, cb, options = EMPTY_OBJ) {
 					activeWatcher = currentWatcher;
 				}
 			}
-		} else effect$1.run();
+		} else effect.run();
 	};
 	if (augmentJob) augmentJob(job);
-	effect$1 = new ReactiveEffect(getter);
-	effect$1.scheduler = scheduler ? () => scheduler(job, false) : job;
-	boundCleanup = (fn) => onWatcherCleanup(fn, false, effect$1);
-	cleanup = effect$1.onStop = () => {
-		const cleanups = cleanupMap.get(effect$1);
+	effect = new ReactiveEffect(getter);
+	effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+	boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
+	cleanup = effect.onStop = () => {
+		const cleanups = cleanupMap.get(effect);
 		if (cleanups) {
 			if (call) call(cleanups, 4);
 			else for (const cleanup2 of cleanups) cleanup2();
-			cleanupMap.delete(effect$1);
+			cleanupMap.delete(effect);
 		}
 	};
 	if (!!(process.env.NODE_ENV !== "production")) {
-		effect$1.onTrack = options.onTrack;
-		effect$1.onTrigger = options.onTrigger;
+		effect.onTrack = options.onTrack;
+		effect.onTrigger = options.onTrigger;
 	}
 	if (cb) if (immediate) job(true);
-	else oldValue = effect$1.run();
+	else oldValue = effect.run();
 	else if (scheduler) scheduler(job.bind(null, true), true);
-	else effect$1.run();
-	watchHandle.pause = effect$1.pause.bind(effect$1);
-	watchHandle.resume = effect$1.resume.bind(effect$1);
+	else effect.run();
+	watchHandle.pause = effect.pause.bind(effect);
+	watchHandle.resume = effect.resume.bind(effect);
 	watchHandle.stop = watchHandle;
 	return watchHandle;
 }
@@ -1535,7 +1611,7 @@ function traverse(value, depth = Infinity, seen) {
 	if ((seen.get(value) || 0) >= depth) return value;
 	seen.set(value, depth);
 	depth--;
-	if (isRef(value)) traverse(value.value, depth, seen);
+	if (/* @__PURE__ */ isRef(value)) traverse(value.value, depth, seen);
 	else if (isArray(value)) for (let i = 0; i < value.length; i++) traverse(value[i], depth, seen);
 	else if (isSet(value) || isMap(value)) value.forEach((v) => {
 		traverse(v, depth, seen);
@@ -1546,9 +1622,13 @@ function traverse(value, depth = Infinity, seen) {
 	}
 	return value;
 }
-
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+runtime-core@3.5.30/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+/**
+* @vue/runtime-core v3.5.30
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 const stack = [];
 function pushWarningContext(vnode) {
 	stack.push(vnode);
@@ -1631,8 +1711,8 @@ function formatProp(key, value, raw) {
 		value = JSON.stringify(value);
 		return raw ? value : [`${key}=${value}`];
 	} else if (typeof value === "number" || typeof value === "boolean" || value == null) return raw ? value : [`${key}=${value}`];
-	else if (isRef(value)) {
-		value = formatProp(key, toRaw(value.value), true);
+	else if (/* @__PURE__ */ isRef(value)) {
+		value = formatProp(key, /* @__PURE__ */ toRaw(value.value), true);
 		return raw ? value : [
 			`${key}=Ref<`,
 			value,
@@ -1640,10 +1720,16 @@ function formatProp(key, value, raw) {
 		];
 	} else if (isFunction(value)) return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
 	else {
-		value = toRaw(value);
+		value = /* @__PURE__ */ toRaw(value);
 		return raw ? value : [`${key}=`, value];
 	}
 }
+function assertNumber(val, type) {
+	if (!!!(process.env.NODE_ENV !== "production")) return;
+	if (val === void 0) return;
+	else if (typeof val !== "number") warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
+	else if (isNaN(val)) warn$1(`${type} is NaN - the duration expression might be incorrect.`);
+}
 const ErrorTypeStrings$1 = {
 	["sp"]: "serverPrefetch hook",
 	["bc"]: "beforeCreate hook",
@@ -1745,8 +1831,8 @@ const resolvedPromise = /* @__PURE__ */ Promise.resolve();
 let currentFlushPromise = null;
 const RECURSION_LIMIT = 100;
 function nextTick(fn) {
-	const p$1 = currentFlushPromise || resolvedPromise;
-	return fn ? p$1.then(this ? fn.bind(this) : fn) : p$1;
+	const p = currentFlushPromise || resolvedPromise;
+	return fn ? p.then(this ? fn.bind(this) : fn) : p;
 }
 function findInsertionIndex(id) {
 	let start = flushIndex + 1;
@@ -1988,8 +2074,8 @@ function setDevtoolsHook$1(hook, target) {
 		buffer = [];
 	}
 }
-function devtoolsInitApp(app, version$1) {
-	emit$1("app:init", app, version$1, {
+function devtoolsInitApp(app, version) {
+	emit$1("app:init", app, version, {
 		Fragment,
 		Text,
 		Comment,
@@ -2099,10 +2185,242 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
 		}
 	}
 }
-const TeleportEndKey = Symbol("_vte");
+function provide(key, value) {
+	if (!!(process.env.NODE_ENV !== "production")) {
+		if (!currentInstance || currentInstance.isMounted) warn$1(`provide() can only be used inside setup().`);
+	}
+	if (currentInstance) {
+		let provides = currentInstance.provides;
+		const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+		if (parentProvides === provides) provides = currentInstance.provides = Object.create(parentProvides);
+		provides[key] = value;
+	}
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+	const instance = getCurrentInstance();
+	if (instance || currentApp) {
+		let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+		if (provides && key in provides) return provides[key];
+		else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+		else if (!!(process.env.NODE_ENV !== "production")) warn$1(`injection "${String(key)}" not found.`);
+	} else if (!!(process.env.NODE_ENV !== "production")) warn$1(`inject() can only be used inside setup() or functional components.`);
+}
+function hasInjectionContext() {
+	return !!(getCurrentInstance() || currentApp);
+}
+const ssrContextKey = /* @__PURE__ */ Symbol.for("v-scx");
+const useSSRContext = () => {
+	{
+		const ctx = inject(ssrContextKey);
+		if (!ctx) process.env.NODE_ENV !== "production" && warn$1(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`);
+		return ctx;
+	}
+};
+function watchEffect(effect, options) {
+	return doWatch(effect, null, options);
+}
+function watch(source, cb, options) {
+	if (!!(process.env.NODE_ENV !== "production") && !isFunction(cb)) warn$1(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`);
+	return doWatch(source, cb, options);
+}
+function doWatch(source, cb, options = EMPTY_OBJ) {
+	const { immediate, deep, flush, once } = options;
+	if (!!(process.env.NODE_ENV !== "production") && !cb) {
+		if (immediate !== void 0) warn$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
+		if (deep !== void 0) warn$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
+		if (once !== void 0) warn$1(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`);
+	}
+	const baseWatchOptions = extend({}, options);
+	if (!!(process.env.NODE_ENV !== "production")) baseWatchOptions.onWarn = warn$1;
+	const runsImmediately = cb && immediate || !cb && flush !== "post";
+	let ssrCleanup;
+	if (isInSSRComponentSetup) {
+		if (flush === "sync") {
+			const ctx = useSSRContext();
+			ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+		} else if (!runsImmediately) {
+			const watchStopHandle = () => {};
+			watchStopHandle.stop = NOOP;
+			watchStopHandle.resume = NOOP;
+			watchStopHandle.pause = NOOP;
+			return watchStopHandle;
+		}
+	}
+	const instance = currentInstance;
+	baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+	let isPre = false;
+	if (flush === "post") baseWatchOptions.scheduler = (job) => {
+		queuePostRenderEffect(job, instance && instance.suspense);
+	};
+	else if (flush !== "sync") {
+		isPre = true;
+		baseWatchOptions.scheduler = (job, isFirstRun) => {
+			if (isFirstRun) job();
+			else queueJob(job);
+		};
+	}
+	baseWatchOptions.augmentJob = (job) => {
+		if (cb) job.flags |= 4;
+		if (isPre) {
+			job.flags |= 2;
+			if (instance) {
+				job.id = instance.uid;
+				job.i = instance;
+			}
+		}
+	};
+	const watchHandle = watch$1(source, cb, baseWatchOptions);
+	if (isInSSRComponentSetup) {
+		if (ssrCleanup) ssrCleanup.push(watchHandle);
+		else if (runsImmediately) watchHandle();
+	}
+	return watchHandle;
+}
+function instanceWatch(source, value, options) {
+	const publicThis = this.proxy;
+	const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+	let cb;
+	if (isFunction(value)) cb = value;
+	else {
+		cb = value.handler;
+		options = value;
+	}
+	const reset = setCurrentInstance(this);
+	const res = doWatch(getter, cb.bind(publicThis), options);
+	reset();
+	return res;
+}
+function createPathGetter(ctx, path) {
+	const segments = path.split(".");
+	return () => {
+		let cur = ctx;
+		for (let i = 0; i < segments.length && cur; i++) cur = cur[segments[i]];
+		return cur;
+	};
+}
+const TeleportEndKey = /* @__PURE__ */ Symbol("_vte");
 const isTeleport = (type) => type.__isTeleport;
-const leaveCbKey = Symbol("_leaveCb");
-const enterCbKey$1 = Symbol("_enterCb");
+const leaveCbKey = /* @__PURE__ */ Symbol("_leaveCb");
+const enterCbKey$1 = /* @__PURE__ */ Symbol("_enterCb");
+function useTransitionState() {
+	const state = {
+		isMounted: false,
+		isLeaving: false,
+		isUnmounting: false,
+		leavingVNodes: /* @__PURE__ */ new Map()
+	};
+	onMounted(() => {
+		state.isMounted = true;
+	});
+	onBeforeUnmount(() => {
+		state.isUnmounting = true;
+	});
+	return state;
+}
+const TransitionHookValidator = [Function, Array];
+const BaseTransitionPropsValidators = {
+	mode: String,
+	appear: Boolean,
+	persisted: Boolean,
+	onBeforeEnter: TransitionHookValidator,
+	onEnter: TransitionHookValidator,
+	onAfterEnter: TransitionHookValidator,
+	onEnterCancelled: TransitionHookValidator,
+	onBeforeLeave: TransitionHookValidator,
+	onLeave: TransitionHookValidator,
+	onAfterLeave: TransitionHookValidator,
+	onLeaveCancelled: TransitionHookValidator,
+	onBeforeAppear: TransitionHookValidator,
+	onAppear: TransitionHookValidator,
+	onAfterAppear: TransitionHookValidator,
+	onAppearCancelled: TransitionHookValidator
+};
+function getLeavingNodesForType(state, vnode) {
+	const { leavingVNodes } = state;
+	let leavingVNodesCache = leavingVNodes.get(vnode.type);
+	if (!leavingVNodesCache) {
+		leavingVNodesCache = /* @__PURE__ */ Object.create(null);
+		leavingVNodes.set(vnode.type, leavingVNodesCache);
+	}
+	return leavingVNodesCache;
+}
+function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+	const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;
+	const key = String(vnode.key);
+	const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+	const callHook = (hook, args) => {
+		hook && callWithAsyncErrorHandling(hook, instance, 9, args);
+	};
+	const callAsyncHook = (hook, args) => {
+		const done = args[1];
+		callHook(hook, args);
+		if (isArray(hook)) {
+			if (hook.every((hook2) => hook2.length <= 1)) done();
+		} else if (hook.length <= 1) done();
+	};
+	const hooks = {
+		mode,
+		persisted,
+		beforeEnter(el) {
+			let hook = onBeforeEnter;
+			if (!state.isMounted) if (appear) hook = onBeforeAppear || onBeforeEnter;
+			else return;
+			if (el[leaveCbKey]) el[leaveCbKey](true);
+			const leavingVNode = leavingVNodesCache[key];
+			if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) leavingVNode.el[leaveCbKey]();
+			callHook(hook, [el]);
+		},
+		enter(el) {
+			if (leavingVNodesCache[key] === vnode) return;
+			let hook = onEnter;
+			let afterHook = onAfterEnter;
+			let cancelHook = onEnterCancelled;
+			if (!state.isMounted) if (appear) {
+				hook = onAppear || onEnter;
+				afterHook = onAfterAppear || onAfterEnter;
+				cancelHook = onAppearCancelled || onEnterCancelled;
+			} else return;
+			let called = false;
+			el[enterCbKey$1] = (cancelled) => {
+				if (called) return;
+				called = true;
+				if (cancelled) callHook(cancelHook, [el]);
+				else callHook(afterHook, [el]);
+				if (hooks.delayedLeave) hooks.delayedLeave();
+				el[enterCbKey$1] = void 0;
+			};
+			const done = el[enterCbKey$1].bind(null, false);
+			if (hook) callAsyncHook(hook, [el, done]);
+			else done();
+		},
+		leave(el, remove) {
+			const key2 = String(vnode.key);
+			if (el[enterCbKey$1]) el[enterCbKey$1](true);
+			if (state.isUnmounting) return remove();
+			callHook(onBeforeLeave, [el]);
+			let called = false;
+			el[leaveCbKey] = (cancelled) => {
+				if (called) return;
+				called = true;
+				remove();
+				if (cancelled) callHook(onLeaveCancelled, [el]);
+				else callHook(onAfterLeave, [el]);
+				el[leaveCbKey] = void 0;
+				if (leavingVNodesCache[key2] === vnode) delete leavingVNodesCache[key2];
+			};
+			const done = el[leaveCbKey].bind(null, false);
+			leavingVNodesCache[key2] = vnode;
+			if (onLeave) callAsyncHook(onLeave, [el, done]);
+			else done();
+		},
+		clone(vnode2) {
+			const hooks2 = resolveTransitionHooks(vnode2, props, state, instance, postClone);
+			if (postClone) postClone(hooks2);
+			return hooks2;
+		}
+	};
+	return hooks;
+}
 function setTransitionHooks(vnode, hooks) {
 	if (vnode.shapeFlag & 6 && vnode.component) {
 		vnode.transition = hooks;
@@ -2112,9 +2430,23 @@ function setTransitionHooks(vnode, hooks) {
 		vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
 	} else vnode.transition = hooks;
 }
+function getTransitionRawChildren(children, keepComment = false, parentKey) {
+	let ret = [];
+	let keyedFragmentCount = 0;
+	for (let i = 0; i < children.length; i++) {
+		let child = children[i];
+		const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
+		if (child.type === Fragment) {
+			if (child.patchFlag & 128) keyedFragmentCount++;
+			ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));
+		} else if (keepComment || child.type !== Comment) ret.push(key != null ? cloneVNode(child, { key }) : child);
+	}
+	if (keyedFragmentCount > 1) for (let i = 0; i < ret.length; i++) ret[i].patchFlag = -2;
+	return ret;
+}
 /* @__NO_SIDE_EFFECTS__ */
 function defineComponent(options, extraOptions) {
-	return isFunction(options) ? /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))() : options;
+	return isFunction(options) ? extend({ name: options.name }, extraOptions, { setup: options }) : options;
 }
 function markAsyncBoundary(instance) {
 	instance.ids = [
@@ -2126,21 +2458,24 @@ function markAsyncBoundary(instance) {
 const knownTemplateRefs = /* @__PURE__ */ new WeakSet();
 function useTemplateRef(key) {
 	const i = getCurrentInstance();
-	const r = shallowRef(null);
+	const r = /* @__PURE__ */ shallowRef(null);
 	if (i) {
 		const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
-		let desc;
-		if (!!(process.env.NODE_ENV !== "production") && (desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable) warn$1(`useTemplateRef('${key}') already exists.`);
+		if (!!(process.env.NODE_ENV !== "production") && isTemplateRefKey(refs, key)) warn$1(`useTemplateRef('${key}') already exists.`);
 		else Object.defineProperty(refs, key, {
 			enumerable: true,
 			get: () => r.value,
 			set: (val) => r.value = val
 		});
 	} else if (!!(process.env.NODE_ENV !== "production")) warn$1(`useTemplateRef() is called when there is no active component instance to be associated with.`);
-	const ret = !!(process.env.NODE_ENV !== "production") ? readonly(r) : r;
+	const ret = !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ readonly(r) : r;
 	if (!!(process.env.NODE_ENV !== "production")) knownTemplateRefs.add(ret);
 	return ret;
 }
+function isTemplateRefKey(refs, key) {
+	let desc;
+	return !!((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable);
+}
 const pendingSetRefMap = /* @__PURE__ */ new WeakMap();
 function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
 	if (isArray(rawRef)) {
@@ -2153,7 +2488,7 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
 	}
 	const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
 	const value = isUnmount ? null : refValue;
-	const { i: owner, r: ref$1 } = rawRef;
+	const { i: owner, r: ref } = rawRef;
 	if (!!(process.env.NODE_ENV !== "production") && !owner) {
 		warn$1(`Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`);
 		return;
@@ -2161,53 +2496,56 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
 	const oldRef = oldRawRef && oldRawRef.r;
 	const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
 	const setupState = owner.setupState;
-	const rawSetupState = toRaw(setupState);
+	const rawSetupState = /* @__PURE__ */ toRaw(setupState);
 	const canSetSetupRef = setupState === EMPTY_OBJ ? NO : (key) => {
 		if (!!(process.env.NODE_ENV !== "production")) {
-			if (hasOwn$1(rawSetupState, key) && !isRef(rawSetupState[key])) warn$1(`Template ref "${key}" used on a non-ref value. It will not work in the production build.`);
+			if (hasOwn(rawSetupState, key) && !/* @__PURE__ */ isRef(rawSetupState[key])) warn$1(`Template ref "${key}" used on a non-ref value. It will not work in the production build.`);
 			if (knownTemplateRefs.has(rawSetupState[key])) return false;
 		}
-		return hasOwn$1(rawSetupState, key);
+		if (isTemplateRefKey(refs, key)) return false;
+		return hasOwn(rawSetupState, key);
 	};
-	const canSetRef = (ref2) => {
-		return !!!(process.env.NODE_ENV !== "production") || !knownTemplateRefs.has(ref2);
+	const canSetRef = (ref2, key) => {
+		if (!!(process.env.NODE_ENV !== "production") && knownTemplateRefs.has(ref2)) return false;
+		if (key && isTemplateRefKey(refs, key)) return false;
+		return true;
 	};
-	if (oldRef != null && oldRef !== ref$1) {
+	if (oldRef != null && oldRef !== ref) {
 		invalidatePendingSetRef(oldRawRef);
 		if (isString(oldRef)) {
 			refs[oldRef] = null;
 			if (canSetSetupRef(oldRef)) setupState[oldRef] = null;
-		} else if (isRef(oldRef)) {
-			if (canSetRef(oldRef)) oldRef.value = null;
+		} else if (/* @__PURE__ */ isRef(oldRef)) {
 			const oldRawRefAtom = oldRawRef;
+			if (canSetRef(oldRef, oldRawRefAtom.k)) oldRef.value = null;
 			if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
 		}
 	}
-	if (isFunction(ref$1)) callWithErrorHandling(ref$1, owner, 12, [value, refs]);
+	if (isFunction(ref)) callWithErrorHandling(ref, owner, 12, [value, refs]);
 	else {
-		const _isString = isString(ref$1);
-		const _isRef = isRef(ref$1);
+		const _isString = isString(ref);
+		const _isRef = /* @__PURE__ */ isRef(ref);
 		if (_isString || _isRef) {
 			const doSet = () => {
 				if (rawRef.f) {
-					const existing = _isString ? canSetSetupRef(ref$1) ? setupState[ref$1] : refs[ref$1] : canSetRef(ref$1) || !rawRef.k ? ref$1.value : refs[rawRef.k];
+					const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : canSetRef(ref) || !rawRef.k ? ref.value : refs[rawRef.k];
 					if (isUnmount) isArray(existing) && remove(existing, refValue);
 					else if (!isArray(existing)) if (_isString) {
-						refs[ref$1] = [refValue];
-						if (canSetSetupRef(ref$1)) setupState[ref$1] = refs[ref$1];
+						refs[ref] = [refValue];
+						if (canSetSetupRef(ref)) setupState[ref] = refs[ref];
 					} else {
 						const newVal = [refValue];
-						if (canSetRef(ref$1)) ref$1.value = newVal;
+						if (canSetRef(ref, rawRef.k)) ref.value = newVal;
 						if (rawRef.k) refs[rawRef.k] = newVal;
 					}
 					else if (!existing.includes(refValue)) existing.push(refValue);
 				} else if (_isString) {
-					refs[ref$1] = value;
-					if (canSetSetupRef(ref$1)) setupState[ref$1] = value;
+					refs[ref] = value;
+					if (canSetSetupRef(ref)) setupState[ref] = value;
 				} else if (_isRef) {
-					if (canSetRef(ref$1)) ref$1.value = value;
+					if (canSetRef(ref, rawRef.k)) ref.value = value;
 					if (rawRef.k) refs[rawRef.k] = value;
-				} else if (!!(process.env.NODE_ENV !== "production")) warn$1("Invalid template ref type:", ref$1, `(${typeof ref$1})`);
+				} else if (!!(process.env.NODE_ENV !== "production")) warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
 			};
 			if (value) {
 				const job = () => {
@@ -2221,7 +2559,7 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
 				invalidatePendingSetRef(rawRef);
 				doSet();
 			}
-		} else if (!!(process.env.NODE_ENV !== "production")) warn$1("Invalid template ref type:", ref$1, `(${typeof ref$1})`);
+		} else if (!!(process.env.NODE_ENV !== "production")) warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
 	}
 }
 function invalidatePendingSetRef(rawRef) {
@@ -2231,9 +2569,130 @@ function invalidatePendingSetRef(rawRef) {
 		pendingSetRefMap.delete(rawRef);
 	}
 }
-const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
-const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+const isComment = (node) => node.nodeType === 8;
+getGlobalThis().requestIdleCallback;
+getGlobalThis().cancelIdleCallback;
+function forEachElement(node, cb) {
+	if (isComment(node) && node.data === "[") {
+		let depth = 1;
+		let next = node.nextSibling;
+		while (next) {
+			if (next.nodeType === 1) {
+				if (cb(next) === false) break;
+			} else if (isComment(next)) {
+				if (next.data === "]") {
+					if (--depth === 0) break;
+				} else if (next.data === "[") depth++;
+			}
+			next = next.nextSibling;
+		}
+	} else cb(node);
+}
 const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+/* @__NO_SIDE_EFFECTS__ */
+function defineAsyncComponent(source) {
+	if (isFunction(source)) source = { loader: source };
+	const { loader, loadingComponent, errorComponent, delay = 200, hydrate: hydrateStrategy, timeout, suspensible = true, onError: userOnError } = source;
+	let pendingRequest = null;
+	let resolvedComp;
+	let retries = 0;
+	const retry = () => {
+		retries++;
+		pendingRequest = null;
+		return load();
+	};
+	const load = () => {
+		let thisRequest;
+		return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
+			err = err instanceof Error ? err : new Error(String(err));
+			if (userOnError) return new Promise((resolve, reject) => {
+				const userRetry = () => resolve(retry());
+				const userFail = () => reject(err);
+				userOnError(err, userRetry, userFail, retries + 1);
+			});
+			else throw err;
+		}).then((comp) => {
+			if (thisRequest !== pendingRequest && pendingRequest) return pendingRequest;
+			if (!!(process.env.NODE_ENV !== "production") && !comp) warn$1(`Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`);
+			if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) comp = comp.default;
+			if (!!(process.env.NODE_ENV !== "production") && comp && !isObject$1(comp) && !isFunction(comp)) throw new Error(`Invalid async component load result: ${comp}`);
+			resolvedComp = comp;
+			return comp;
+		}));
+	};
+	return /* @__PURE__ */ defineComponent({
+		name: "AsyncComponentWrapper",
+		__asyncLoader: load,
+		__asyncHydrate(el, instance, hydrate) {
+			let patched = false;
+			(instance.bu || (instance.bu = [])).push(() => patched = true);
+			const performHydrate = () => {
+				if (patched) {
+					if (!!(process.env.NODE_ENV !== "production")) warn$1(`Skipping lazy hydration for component '${getComponentName(resolvedComp) || resolvedComp.__file}': it was updated before lazy hydration performed.`);
+					return;
+				}
+				hydrate();
+			};
+			const doHydrate = hydrateStrategy ? () => {
+				const teardown = hydrateStrategy(performHydrate, (cb) => forEachElement(el, cb));
+				if (teardown) (instance.bum || (instance.bum = [])).push(teardown);
+			} : performHydrate;
+			if (resolvedComp) doHydrate();
+			else load().then(() => !instance.isUnmounted && doHydrate());
+		},
+		get __asyncResolved() {
+			return resolvedComp;
+		},
+		setup() {
+			const instance = currentInstance;
+			markAsyncBoundary(instance);
+			if (resolvedComp) return () => createInnerComp(resolvedComp, instance);
+			const onError = (err) => {
+				pendingRequest = null;
+				handleError(err, instance, 13, !errorComponent);
+			};
+			if (suspensible && instance.suspense || isInSSRComponentSetup) return load().then((comp) => {
+				return () => createInnerComp(comp, instance);
+			}).catch((err) => {
+				onError(err);
+				return () => errorComponent ? createVNode(errorComponent, { error: err }) : null;
+			});
+			const loaded = /* @__PURE__ */ ref(false);
+			const error = /* @__PURE__ */ ref();
+			const delayed = /* @__PURE__ */ ref(!!delay);
+			if (delay) setTimeout(() => {
+				delayed.value = false;
+			}, delay);
+			if (timeout != null) setTimeout(() => {
+				if (!loaded.value && !error.value) {
+					const err = /* @__PURE__ */ new Error(`Async component timed out after ${timeout}ms.`);
+					onError(err);
+					error.value = err;
+				}
+			}, timeout);
+			load().then(() => {
+				loaded.value = true;
+				if (instance.parent && isKeepAlive(instance.parent.vnode)) instance.parent.update();
+			}).catch((err) => {
+				onError(err);
+				error.value = err;
+			});
+			return () => {
+				if (loaded.value && resolvedComp) return createInnerComp(resolvedComp, instance);
+				else if (error.value && errorComponent) return createVNode(errorComponent, { error: error.value });
+				else if (loadingComponent && !delayed.value) return createInnerComp(loadingComponent, instance);
+			};
+		}
+	});
+}
+function createInnerComp(comp, parent) {
+	const { ref: ref2, props, children, ce } = parent.vnode;
+	const vnode = createVNode(comp, props, children);
+	vnode.ref = ref2;
+	vnode.ce = ce;
+	delete parent.vnode.ce;
+	return vnode;
+}
 const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
 function onActivated(hook, target) {
 	registerKeepAliveHook(hook, "a", target);
@@ -2296,27 +2755,30 @@ const onRenderTracked = createHook("rtc");
 function onErrorCaptured(hook, target = currentInstance) {
 	injectHook("ec", hook, target);
 }
-const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+const NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
 function renderList(source, renderItem, cache, index) {
 	let ret;
 	const cached = cache && cache[index];
 	const sourceIsArray = isArray(source);
 	if (sourceIsArray || isString(source)) {
-		const sourceIsReactiveArray = sourceIsArray && isReactive(source);
+		const sourceIsReactiveArray = sourceIsArray && /* @__PURE__ */ isReactive(source);
 		let needsWrap = false;
 		let isReadonlySource = false;
 		if (sourceIsReactiveArray) {
-			needsWrap = !isShallow(source);
-			isReadonlySource = isReadonly(source);
+			needsWrap = !/* @__PURE__ */ isShallow(source);
+			isReadonlySource = /* @__PURE__ */ isReadonly(source);
 			source = shallowReadArray(source);
 		}
 		ret = new Array(source.length);
 		for (let i = 0, l = source.length; i < l; i++) ret[i] = renderItem(needsWrap ? isReadonlySource ? toReadonly(toReactive(source[i])) : toReactive(source[i]) : source[i], i, void 0, cached && cached[i]);
-	} else if (typeof source === "number") {
-		if (!!(process.env.NODE_ENV !== "production") && !Number.isInteger(source)) warn$1(`The v-for range expect an integer value but got ${source}.`);
+	} else if (typeof source === "number") if (!!(process.env.NODE_ENV !== "production") && (!Number.isInteger(source) || source < 0)) {
+		warn$1(`The v-for range expects a positive integer value but got ${source}.`);
+		ret = [];
+	} else {
 		ret = new Array(source);
 		for (let i = 0; i < source; i++) ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
-	} else if (isObject$1(source)) if (source[Symbol.iterator]) ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));
+	}
+	else if (isObject$1(source)) if (source[Symbol.iterator]) ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));
 	else {
 		const keys = Object.keys(source);
 		ret = new Array(keys.length);
@@ -2366,10 +2828,10 @@ const publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create
 	$: (i) => i,
 	$el: (i) => i.vnode.el,
 	$data: (i) => i.data,
-	$props: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.props) : i.props,
-	$attrs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.attrs) : i.attrs,
-	$slots: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.slots) : i.slots,
-	$refs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly(i.refs) : i.refs,
+	$props: (i) => !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(i.props) : i.props,
+	$attrs: (i) => !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(i.attrs) : i.attrs,
+	$slots: (i) => !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(i.slots) : i.slots,
+	$refs: (i) => !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(i.refs) : i.refs,
 	$parent: (i) => getPublicInstance(i.parent),
 	$root: (i) => getPublicInstance(i.root),
 	$host: (i) => i.ce,
@@ -2382,13 +2844,12 @@ const publicPropertiesMap = /* @__PURE__ */ extend(/* @__PURE__ */ Object.create
 	$watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP
 });
 const isReservedPrefix = (key) => key === "_" || key === "$";
-const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn$1(state, key);
+const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
 const PublicInstanceProxyHandlers = {
 	get({ _: instance }, key) {
 		if (key === "__v_skip") return true;
 		const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
 		if (!!(process.env.NODE_ENV !== "production") && key === "__isVue") return true;
-		let normalizedProps;
 		if (key[0] !== "$") {
 			const n = accessCache[key];
 			if (n !== void 0) switch (n) {
@@ -2400,13 +2861,13 @@ const PublicInstanceProxyHandlers = {
 			else if (hasSetupBinding(setupState, key)) {
 				accessCache[key] = 1;
 				return setupState[key];
-			} else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) {
+			} else if (__VUE_OPTIONS_API__ && data !== EMPTY_OBJ && hasOwn(data, key)) {
 				accessCache[key] = 2;
 				return data[key];
-			} else if ((normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key)) {
+			} else if (hasOwn(props, key)) {
 				accessCache[key] = 3;
 				return props[key];
-			} else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
+			} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
 				accessCache[key] = 4;
 				return ctx[key];
 			} else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) accessCache[key] = 0;
@@ -2420,12 +2881,12 @@ const PublicInstanceProxyHandlers = {
 			} else if (!!(process.env.NODE_ENV !== "production") && key === "$slots") track(instance, "get", key);
 			return publicGetter(instance);
 		} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
-		else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
+		else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
 			accessCache[key] = 4;
 			return ctx[key];
-		} else if (globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key)) return globalProperties[key];
+		} else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) return globalProperties[key];
 		else if (!!(process.env.NODE_ENV !== "production") && currentRenderingInstance && (!isString(key) || key.indexOf("__v") !== 0)) {
-			if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn$1(data, key)) warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`);
+			if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) warn$1(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`);
 			else if (instance === currentRenderingInstance) warn$1(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`);
 		}
 	},
@@ -2434,13 +2895,13 @@ const PublicInstanceProxyHandlers = {
 		if (hasSetupBinding(setupState, key)) {
 			setupState[key] = value;
 			return true;
-		} else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn$1(setupState, key)) {
+		} else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn(setupState, key)) {
 			warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
 			return false;
-		} else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) {
+		} else if (__VUE_OPTIONS_API__ && data !== EMPTY_OBJ && hasOwn(data, key)) {
 			data[key] = value;
 			return true;
-		} else if (hasOwn$1(instance.props, key)) {
+		} else if (hasOwn(instance.props, key)) {
 			process.env.NODE_ENV !== "production" && warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
 			return false;
 		}
@@ -2455,13 +2916,13 @@ const PublicInstanceProxyHandlers = {
 		else ctx[key] = value;
 		return true;
 	},
-	has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions, type } }, key) {
-		let normalizedProps, cssModules;
-		return !!(accessCache[key] || data !== EMPTY_OBJ && key[0] !== "$" && hasOwn$1(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap, key) || hasOwn$1(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
+	has({ _: { data, setupState, accessCache, ctx, appContext, props, type } }, key) {
+		let cssModules;
+		return !!(accessCache[key] || __VUE_OPTIONS_API__ && data !== EMPTY_OBJ && key[0] !== "$" && hasOwn(data, key) || hasSetupBinding(setupState, key) || hasOwn(props, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
 	},
 	defineProperty(target, key, descriptor) {
 		if (descriptor.get != null) target._.accessCache[key] = 0;
-		else if (hasOwn$1(descriptor, "value")) this.set(target, key, descriptor.value, null);
+		else if (hasOwn(descriptor, "value")) this.set(target, key, descriptor.value, null);
 		return Reflect.defineProperty(target, key, descriptor);
 	}
 };
@@ -2499,7 +2960,7 @@ function exposePropsOnRenderContext(instance) {
 }
 function exposeSetupStateOnRenderContext(instance) {
 	const { ctx, setupState } = instance;
-	Object.keys(toRaw(setupState)).forEach((key) => {
+	Object.keys(/* @__PURE__ */ toRaw(setupState)).forEach((key) => {
 		if (!setupState.__isScriptSetup) {
 			if (isReservedPrefix(key[0])) {
 				warn$1(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" which are reserved prefixes for Vue internals.`);
@@ -2515,12 +2976,7 @@ function exposeSetupStateOnRenderContext(instance) {
 	});
 }
 function normalizePropsOrEmits(props) {
-	return isArray(props) ? props.reduce((normalized, p$1) => (normalized[p$1] = null, normalized), {}) : props;
-}
-function mergeModels(a, b) {
-	if (!a || !b) return a || b;
-	if (isArray(a) && isArray(b)) return a.concat(b);
-	return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+	return isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
 }
 function createDuplicateChecker() {
 	const cache = /* @__PURE__ */ Object.create(null);
@@ -2535,8 +2991,8 @@ function applyOptions(instance) {
 	const publicThis = instance.proxy;
 	const ctx = instance.ctx;
 	shouldCacheAccess = false;
-	if (options.beforeCreate) callHook(options.beforeCreate, instance, "bc");
-	const { data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render: render$1, renderTracked, renderTriggered, errorCaptured, serverPrefetch, expose, inheritAttrs, components, directives, filters } = options;
+	if (options.beforeCreate) callHook$1(options.beforeCreate, instance, "bc");
+	const { data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, expose, inheritAttrs, components, directives, filters } = options;
 	const checkDuplicateProperties = !!(process.env.NODE_ENV !== "production") ? createDuplicateChecker() : null;
 	if (!!(process.env.NODE_ENV !== "production")) {
 		const [propsOptions] = instance.propsOptions;
@@ -2562,7 +3018,7 @@ function applyOptions(instance) {
 		if (!!(process.env.NODE_ENV !== "production") && isPromise(data)) warn$1(`data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`);
 		if (!isObject$1(data)) process.env.NODE_ENV !== "production" && warn$1(`data() should return an object.`);
 		else {
-			instance.data = reactive(data);
+			instance.data = /* @__PURE__ */ reactive(data);
 			if (!!(process.env.NODE_ENV !== "production")) for (const key in data) {
 				checkDuplicateProperties("Data", key);
 				if (!isReservedPrefix(key[0])) Object.defineProperty(ctx, key, {
@@ -2600,7 +3056,7 @@ function applyOptions(instance) {
 			provide(key, provides[key]);
 		});
 	}
-	if (created) callHook(created, instance, "c");
+	if (created) callHook$1(created, instance, "c");
 	function registerLifecycleHook(register, hook) {
 		if (isArray(hook)) hook.forEach((_hook) => register(_hook.bind(publicThis)));
 		else if (hook) register(hook.bind(publicThis));
@@ -2629,7 +3085,7 @@ function applyOptions(instance) {
 			});
 		} else if (!instance.exposed) instance.exposed = {};
 	}
-	if (render$1 && instance.render === NOOP) instance.render = render$1;
+	if (render && instance.render === NOOP) instance.render = render;
 	if (inheritAttrs != null) instance.inheritAttrs = inheritAttrs;
 	if (components) instance.components = components;
 	if (directives) instance.directives = directives;
@@ -2643,7 +3099,7 @@ function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP)
 		if (isObject$1(opt)) if ("default" in opt) injected = inject(opt.from || key, opt.default, true);
 		else injected = inject(opt.from || key);
 		else injected = inject(opt);
-		if (isRef(injected)) Object.defineProperty(ctx, key, {
+		if (/* @__PURE__ */ isRef(injected)) Object.defineProperty(ctx, key, {
 			enumerable: true,
 			configurable: true,
 			get: () => injected.value,
@@ -2653,8 +3109,8 @@ function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP)
 		if (!!(process.env.NODE_ENV !== "production")) checkDuplicateProperties("Inject", key);
 	}
 }
-function callHook(hook, instance, type) {
-	callWithAsyncErrorHandling(isArray(hook) ? hook.map((h$1) => h$1.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type);
+function callHook$1(hook, instance, type) {
+	callWithAsyncErrorHandling(isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type);
 }
 function createWatcher(raw, ctx, publicThis, key) {
 	let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
@@ -2783,8 +3239,8 @@ function createAppContext() {
 	};
 }
 let uid$1 = 0;
-function createAppAPI(render$1, hydrate) {
-	return function createApp$1(rootComponent, rootProps = null) {
+function createAppAPI(render, hydrate) {
+	return function createApp(rootComponent, rootProps = null) {
 		if (!isFunction(rootComponent)) rootComponent = extend({}, rootComponent);
 		if (rootProps != null && !isObject$1(rootProps)) {
 			process.env.NODE_ENV !== "production" && warn$1(`root props passed to app.mount() must be an object.`);
@@ -2851,10 +3307,10 @@ function createAppAPI(render$1, hydrate) {
 					if (!!(process.env.NODE_ENV !== "production")) context.reload = () => {
 						const cloned = cloneVNode(vnode);
 						cloned.el = null;
-						render$1(cloned, rootContainer, namespace);
+						render(cloned, rootContainer, namespace);
 					};
 					if (isHydrate && hydrate) hydrate(vnode, rootContainer);
-					else render$1(vnode, rootContainer, namespace);
+					else render(vnode, rootContainer, namespace);
 					isMounted = true;
 					app._container = rootContainer;
 					rootContainer.__vue_app__ = app;
@@ -2873,7 +3329,7 @@ If you want to remount the same app, move your app creation logic into a factory
 			unmount() {
 				if (isMounted) {
 					callWithAsyncErrorHandling(pluginCleanupFns, app._instance, 16);
-					render$1(null, app._container);
+					render(null, app._container);
 					if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
 						app._instance = null;
 						devtoolsUnmountApp(app);
@@ -2882,7 +3338,7 @@ If you want to remount the same app, move your app creation logic into a factory
 				} else if (!!(process.env.NODE_ENV !== "production")) warn$1(`Cannot unmount an app that is not mounted.`);
 			},
 			provide(key, value) {
-				if (!!(process.env.NODE_ENV !== "production") && key in context.provides) if (hasOwn$1(context.provides, key)) warn$1(`App already provides property with key "${String(key)}". It will be overwritten with the new value.`);
+				if (!!(process.env.NODE_ENV !== "production") && key in context.provides) if (hasOwn(context.provides, key)) warn$1(`App already provides property with key "${String(key)}". It will be overwritten with the new value.`);
 				else warn$1(`App already provides property with key "${String(key)}" inherited from its parent element. It will be overwritten with the new value.`);
 				context.provides[key] = value;
 				return app;
@@ -2901,54 +3357,285 @@ If you want to remount the same app, move your app creation logic into a factory
 	};
 }
 let currentApp = null;
-function provide(key, value) {
-	if (!currentInstance) {
-		if (!!(process.env.NODE_ENV !== "production")) warn$1(`provide() can only be used inside setup().`);
-	} else {
-		let provides = currentInstance.provides;
-		const parentProvides = currentInstance.parent && currentInstance.parent.provides;
-		if (parentProvides === provides) provides = currentInstance.provides = Object.create(parentProvides);
-		provides[key] = value;
+const getModelModifiers = (props, modelName) => {
+	return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize$1(modelName)}Modifiers`] || props[`${hyphenate$1(modelName)}Modifiers`];
+};
+function emit(instance, event, ...rawArgs) {
+	if (instance.isUnmounted) return;
+	const props = instance.vnode.props || EMPTY_OBJ;
+	if (!!(process.env.NODE_ENV !== "production")) {
+		const { emitsOptions, propsOptions: [propsOptions] } = instance;
+		if (emitsOptions) if (!(event in emitsOptions) && true) {
+			if (!propsOptions || !(toHandlerKey(camelize$1(event)) in propsOptions)) warn$1(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(camelize$1(event))}" prop.`);
+		} else {
+			const validator = emitsOptions[event];
+			if (isFunction(validator)) {
+				if (!validator(...rawArgs)) warn$1(`Invalid event arguments: event validation failed for event "${event}".`);
+			}
+		}
 	}
-}
-function inject(key, defaultValue, treatDefaultAsFactory = false) {
-	const instance = getCurrentInstance();
-	if (instance || currentApp) {
-		let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
-		if (provides && key in provides) return provides[key];
-		else if (arguments.length > 1) return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
-		else if (!!(process.env.NODE_ENV !== "production")) warn$1(`injection "${String(key)}" not found.`);
-	} else if (!!(process.env.NODE_ENV !== "production")) warn$1(`inject() can only be used inside setup() or functional components.`);
-}
-function hasInjectionContext() {
-	return !!(getCurrentInstance() || currentApp);
-}
-const internalObjectProto = {};
-const createInternalObject = () => Object.create(internalObjectProto);
-const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
-function initProps(instance, rawProps, isStateful, isSSR = false) {
-	const props = {};
-	const attrs = createInternalObject();
-	instance.propsDefaults = /* @__PURE__ */ Object.create(null);
-	setFullProps(instance, rawProps, props, attrs);
-	for (const key in instance.propsOptions[0]) if (!(key in props)) props[key] = void 0;
-	if (!!(process.env.NODE_ENV !== "production")) validateProps(rawProps || {}, props, instance);
-	if (isStateful) instance.props = isSSR ? props : shallowReactive(props);
-	else if (!instance.type.props) instance.props = attrs;
-	else instance.props = props;
-	instance.attrs = attrs;
-}
-function isInHmrContext(instance) {
-	while (instance) {
-		if (instance.type.__hmrId) return true;
-		instance = instance.parent;
+	let args = rawArgs;
+	const isModelListener = event.startsWith("update:");
+	const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
+	if (modifiers) {
+		if (modifiers.trim) args = rawArgs.map((a) => isString(a) ? a.trim() : a);
+		if (modifiers.number) args = rawArgs.map(looseToNumber);
 	}
-}
-function updateProps(instance, rawProps, rawPrevProps, optimized) {
-	const { props, attrs, vnode: { patchFlag } } = instance;
-	const rawCurrentProps = toRaw(props);
-	const [options] = instance.propsOptions;
-	let hasAttrsChanged = false;
+	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsComponentEmit(instance, event, args);
+	if (!!(process.env.NODE_ENV !== "production")) {
+		const lowerCaseEvent = event.toLowerCase();
+		if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) warn$1(`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate$1(event)}" instead of "${event}".`);
+	}
+	let handlerName;
+	let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize$1(event))];
+	if (!handler && isModelListener) handler = props[handlerName = toHandlerKey(hyphenate$1(event))];
+	if (handler) callWithAsyncErrorHandling(handler, instance, 6, args);
+	const onceHandler = props[handlerName + `Once`];
+	if (onceHandler) {
+		if (!instance.emitted) instance.emitted = {};
+		else if (instance.emitted[handlerName]) return;
+		instance.emitted[handlerName] = true;
+		callWithAsyncErrorHandling(onceHandler, instance, 6, args);
+	}
+}
+const mixinEmitsCache = /* @__PURE__ */ new WeakMap();
+function normalizeEmitsOptions(comp, appContext, asMixin = false) {
+	const cache = __VUE_OPTIONS_API__ && asMixin ? mixinEmitsCache : appContext.emitsCache;
+	const cached = cache.get(comp);
+	if (cached !== void 0) return cached;
+	const raw = comp.emits;
+	let normalized = {};
+	let hasExtends = false;
+	if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
+		const extendEmits = (raw2) => {
+			const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+			if (normalizedFromExtend) {
+				hasExtends = true;
+				extend(normalized, normalizedFromExtend);
+			}
+		};
+		if (!asMixin && appContext.mixins.length) appContext.mixins.forEach(extendEmits);
+		if (comp.extends) extendEmits(comp.extends);
+		if (comp.mixins) comp.mixins.forEach(extendEmits);
+	}
+	if (!raw && !hasExtends) {
+		if (isObject$1(comp)) cache.set(comp, null);
+		return null;
+	}
+	if (isArray(raw)) raw.forEach((key) => normalized[key] = null);
+	else extend(normalized, raw);
+	if (isObject$1(comp)) cache.set(comp, normalized);
+	return normalized;
+}
+function isEmitListener(options, key) {
+	if (!options || !isOn(key)) return false;
+	key = key.slice(2).replace(/Once$/, "");
+	return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate$1(key)) || hasOwn(options, key);
+}
+let accessedAttrs = false;
+function markAttrsAccessed() {
+	accessedAttrs = true;
+}
+function renderComponentRoot(instance) {
+	const { type: Component, vnode, proxy, withProxy, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, props, data, setupState, ctx, inheritAttrs } = instance;
+	const prev = setCurrentRenderingInstance(instance);
+	let result;
+	let fallthroughAttrs;
+	if (!!(process.env.NODE_ENV !== "production")) accessedAttrs = false;
+	try {
+		if (vnode.shapeFlag & 4) {
+			const proxyToUse = withProxy || proxy;
+			const thisProxy = !!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup ? new Proxy(proxyToUse, { get(target, key, receiver) {
+				warn$1(`Property '${String(key)}' was accessed via 'this'. Avoid using 'this' in templates.`);
+				return Reflect.get(target, key, receiver);
+			} }) : proxyToUse;
+			result = normalizeVNode(render.call(thisProxy, proxyToUse, renderCache, !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(props) : props, setupState, data, ctx));
+			fallthroughAttrs = attrs;
+		} else {
+			const render2 = Component;
+			if (!!(process.env.NODE_ENV !== "production") && attrs === props) markAttrsAccessed();
+			result = normalizeVNode(render2.length > 1 ? render2(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(props) : props, !!(process.env.NODE_ENV !== "production") ? {
+				get attrs() {
+					markAttrsAccessed();
+					return /* @__PURE__ */ shallowReadonly(attrs);
+				},
+				slots,
+				emit
+			} : {
+				attrs,
+				slots,
+				emit
+			}) : render2(!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(props) : props, null));
+			fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
+		}
+	} catch (err) {
+		blockStack.length = 0;
+		handleError(err, instance, 1);
+		result = createVNode(Comment);
+	}
+	let root = result;
+	let setRoot = void 0;
+	if (!!(process.env.NODE_ENV !== "production") && result.patchFlag > 0 && result.patchFlag & 2048) [root, setRoot] = getChildRoot(result);
+	if (fallthroughAttrs && inheritAttrs !== false) {
+		const keys = Object.keys(fallthroughAttrs);
+		const { shapeFlag } = root;
+		if (keys.length) {
+			if (shapeFlag & 7) {
+				if (propsOptions && keys.some(isModelListener)) fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
+				root = cloneVNode(root, fallthroughAttrs, false, true);
+			} else if (!!(process.env.NODE_ENV !== "production") && !accessedAttrs && root.type !== Comment) {
+				const allAttrs = Object.keys(attrs);
+				const eventAttrs = [];
+				const extraAttrs = [];
+				for (let i = 0, l = allAttrs.length; i < l; i++) {
+					const key = allAttrs[i];
+					if (isOn(key)) {
+						if (!isModelListener(key)) eventAttrs.push(key[2].toLowerCase() + key.slice(3));
+					} else extraAttrs.push(key);
+				}
+				if (extraAttrs.length) warn$1(`Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text or teleport root nodes.`);
+				if (eventAttrs.length) warn$1(`Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`);
+			}
+		}
+	}
+	if (vnode.dirs) {
+		if (!!(process.env.NODE_ENV !== "production") && !isElementRoot(root)) warn$1(`Runtime directive used on component with non-element root node. The directives will not function as intended.`);
+		root = cloneVNode(root, null, false, true);
+		root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+	}
+	if (vnode.transition) {
+		if (!!(process.env.NODE_ENV !== "production") && !isElementRoot(root)) warn$1(`Component inside <Transition> renders non-element root node that cannot be animated.`);
+		setTransitionHooks(root, vnode.transition);
+	}
+	if (!!(process.env.NODE_ENV !== "production") && setRoot) setRoot(root);
+	else result = root;
+	setCurrentRenderingInstance(prev);
+	return result;
+}
+const getChildRoot = (vnode) => {
+	const rawChildren = vnode.children;
+	const dynamicChildren = vnode.dynamicChildren;
+	const childRoot = filterSingleRoot(rawChildren, false);
+	if (!childRoot) return [vnode, void 0];
+	else if (!!(process.env.NODE_ENV !== "production") && childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) return getChildRoot(childRoot);
+	const index = rawChildren.indexOf(childRoot);
+	const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
+	const setRoot = (updatedRoot) => {
+		rawChildren[index] = updatedRoot;
+		if (dynamicChildren) {
+			if (dynamicIndex > -1) dynamicChildren[dynamicIndex] = updatedRoot;
+			else if (updatedRoot.patchFlag > 0) vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
+		}
+	};
+	return [normalizeVNode(childRoot), setRoot];
+};
+function filterSingleRoot(children, recurse = true) {
+	let singleRoot;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (isVNode(child)) {
+			if (child.type !== Comment || child.children === "v-if") if (singleRoot) return;
+			else {
+				singleRoot = child;
+				if (!!(process.env.NODE_ENV !== "production") && recurse && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) return filterSingleRoot(singleRoot.children);
+			}
+		} else return;
+	}
+	return singleRoot;
+}
+const getFunctionalFallthrough = (attrs) => {
+	let res;
+	for (const key in attrs) if (key === "class" || key === "style" || isOn(key)) (res || (res = {}))[key] = attrs[key];
+	return res;
+};
+const filterModelListeners = (attrs, props) => {
+	const res = {};
+	for (const key in attrs) if (!isModelListener(key) || !(key.slice(9) in props)) res[key] = attrs[key];
+	return res;
+};
+const isElementRoot = (vnode) => {
+	return vnode.shapeFlag & 7 || vnode.type === Comment;
+};
+function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+	const { props: prevProps, children: prevChildren, component } = prevVNode;
+	const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+	const emits = component.emitsOptions;
+	if (!!(process.env.NODE_ENV !== "production") && (prevChildren || nextChildren) && isHmrUpdating) return true;
+	if (nextVNode.dirs || nextVNode.transition) return true;
+	if (optimized && patchFlag >= 0) {
+		if (patchFlag & 1024) return true;
+		if (patchFlag & 16) {
+			if (!prevProps) return !!nextProps;
+			return hasPropsChanged(prevProps, nextProps, emits);
+		} else if (patchFlag & 8) {
+			const dynamicProps = nextVNode.dynamicProps;
+			for (let i = 0; i < dynamicProps.length; i++) {
+				const key = dynamicProps[i];
+				if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emits, key)) return true;
+			}
+		}
+	} else {
+		if (prevChildren || nextChildren) {
+			if (!nextChildren || !nextChildren.$stable) return true;
+		}
+		if (prevProps === nextProps) return false;
+		if (!prevProps) return !!nextProps;
+		if (!nextProps) return true;
+		return hasPropsChanged(prevProps, nextProps, emits);
+	}
+	return false;
+}
+function hasPropsChanged(prevProps, nextProps, emitsOptions) {
+	const nextKeys = Object.keys(nextProps);
+	if (nextKeys.length !== Object.keys(prevProps).length) return true;
+	for (let i = 0; i < nextKeys.length; i++) {
+		const key = nextKeys[i];
+		if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emitsOptions, key)) return true;
+	}
+	return false;
+}
+function hasPropValueChanged(nextProps, prevProps, key) {
+	const nextProp = nextProps[key];
+	const prevProp = prevProps[key];
+	if (key === "style" && isObject$1(nextProp) && isObject$1(prevProp)) return !looseEqual(nextProp, prevProp);
+	return nextProp !== prevProp;
+}
+function updateHOCHostEl({ vnode, parent }, el) {
+	while (parent) {
+		const root = parent.subTree;
+		if (root.suspense && root.suspense.activeBranch === vnode) root.el = vnode.el;
+		if (root === vnode) {
+			(vnode = parent.vnode).el = el;
+			parent = parent.parent;
+		} else break;
+	}
+}
+const internalObjectProto = {};
+const createInternalObject = () => Object.create(internalObjectProto);
+const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
+function initProps(instance, rawProps, isStateful, isSSR = false) {
+	const props = {};
+	const attrs = createInternalObject();
+	instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+	setFullProps(instance, rawProps, props, attrs);
+	for (const key in instance.propsOptions[0]) if (!(key in props)) props[key] = void 0;
+	if (!!(process.env.NODE_ENV !== "production")) validateProps(rawProps || {}, props, instance);
+	if (isStateful) instance.props = isSSR ? props : /* @__PURE__ */ shallowReactive(props);
+	else if (!instance.type.props) instance.props = attrs;
+	else instance.props = props;
+	instance.attrs = attrs;
+}
+function isInHmrContext(instance) {
+	while (instance) {
+		if (instance.type.__hmrId) return true;
+		instance = instance.parent;
+	}
+}
+function updateProps(instance, rawProps, rawPrevProps, optimized) {
+	const { props, attrs, vnode: { patchFlag } } = instance;
+	const rawCurrentProps = /* @__PURE__ */ toRaw(props);
+	const [options] = instance.propsOptions;
+	let hasAttrsChanged = false;
 	if (!(!!(process.env.NODE_ENV !== "production") && isInHmrContext(instance)) && (optimized || patchFlag > 0) && !(patchFlag & 16)) {
 		if (patchFlag & 8) {
 			const propsToUpdate = instance.vnode.dynamicProps;
@@ -2956,7 +3643,7 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
 				let key = propsToUpdate[i];
 				if (isEmitListener(instance.emitsOptions, key)) continue;
 				const value = rawProps[key];
-				if (options) if (hasOwn$1(attrs, key)) {
+				if (options) if (hasOwn(attrs, key)) {
 					if (value !== attrs[key]) {
 						attrs[key] = value;
 						hasAttrsChanged = true;
@@ -2974,11 +3661,11 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
 	} else {
 		if (setFullProps(instance, rawProps, props, attrs)) hasAttrsChanged = true;
 		let kebabKey;
-		for (const key in rawCurrentProps) if (!rawProps || !hasOwn$1(rawProps, key) && ((kebabKey = hyphenate$1(key)) === key || !hasOwn$1(rawProps, kebabKey))) if (options) {
+		for (const key in rawCurrentProps) if (!rawProps || !hasOwn(rawProps, key) && ((kebabKey = hyphenate$1(key)) === key || !hasOwn(rawProps, kebabKey))) if (options) {
 			if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) props[key] = resolvePropValue(options, rawCurrentProps, key, void 0, instance, true);
 		} else delete props[key];
 		if (attrs !== rawCurrentProps) {
-			for (const key in attrs) if (!rawProps || !hasOwn$1(rawProps, key) && true) {
+			for (const key in attrs) if (!rawProps || !hasOwn(rawProps, key) && true) {
 				delete attrs[key];
 				hasAttrsChanged = true;
 			}
@@ -2995,7 +3682,7 @@ function setFullProps(instance, rawProps, props, attrs) {
 		if (isReservedProp(key)) continue;
 		const value = rawProps[key];
 		let camelKey;
-		if (options && hasOwn$1(options, camelKey = camelize$1(key))) if (!needCastKeys || !needCastKeys.includes(camelKey)) props[camelKey] = value;
+		if (options && hasOwn(options, camelKey = camelize$1(key))) if (!needCastKeys || !needCastKeys.includes(camelKey)) props[camelKey] = value;
 		else (rawCastValues || (rawCastValues = {}))[camelKey] = value;
 		else if (!isEmitListener(instance.emitsOptions, key)) {
 			if (!(key in attrs) || value !== attrs[key]) {
@@ -3005,11 +3692,11 @@ function setFullProps(instance, rawProps, props, attrs) {
 		}
 	}
 	if (needCastKeys) {
-		const rawCurrentProps = toRaw(props);
+		const rawCurrentProps = /* @__PURE__ */ toRaw(props);
 		const castValues = rawCastValues || EMPTY_OBJ;
 		for (let i = 0; i < needCastKeys.length; i++) {
 			const key = needCastKeys[i];
-			props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn$1(castValues, key));
+			props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key));
 		}
 	}
 	return hasAttrsChanged;
@@ -3017,7 +3704,7 @@ function setFullProps(instance, rawProps, props, attrs) {
 function resolvePropValue(options, props, key, value, instance, isAbsent) {
 	const opt = options[key];
 	if (opt != null) {
-		const hasDefault = hasOwn$1(opt, "default");
+		const hasDefault = hasOwn(opt, "default");
 		if (hasDefault && value === void 0) {
 			const defaultValue = opt.default;
 			if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
@@ -3088,7 +3775,7 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
 				else shouldCast = isFunction(propType) && propType.name === "Boolean";
 				prop[0] = shouldCast;
 				prop[1] = shouldCastTrue;
-				if (shouldCast || hasOwn$1(prop, "default")) needCastKeys.push(normalizedKey);
+				if (shouldCast || hasOwn(prop, "default")) needCastKeys.push(normalizedKey);
 			}
 		}
 	}
@@ -3108,13 +3795,13 @@ function getType(ctor) {
 	return "";
 }
 function validateProps(rawProps, props, instance) {
-	const resolvedValues = toRaw(props);
+	const resolvedValues = /* @__PURE__ */ toRaw(props);
 	const options = instance.propsOptions[0];
 	const camelizePropsKey = Object.keys(rawProps).map((key) => camelize$1(key));
 	for (const key in options) {
 		let opt = options[key];
 		if (opt == null) continue;
-		validateProp(key, resolvedValues[key], opt, !!(process.env.NODE_ENV !== "production") ? shallowReadonly(resolvedValues) : resolvedValues, !camelizePropsKey.includes(key));
+		validateProp(key, resolvedValues[key], opt, !!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(resolvedValues) : resolvedValues, !camelizePropsKey.includes(key));
 	}
 }
 function validateProp(name, value, prop, props, isAbsent) {
@@ -3319,7 +4006,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 			optimized = false;
 			n2.dynamicChildren = null;
 		}
-		const { type, ref: ref$1, shapeFlag } = n2;
+		const { type, ref, shapeFlag } = n2;
 		switch (type) {
 			case Text:
 				processText(n1, n2, container, anchor);
@@ -3340,8 +4027,8 @@ function baseCreateRenderer(options, createHydrationFns) {
 			else if (shapeFlag & 128) type.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals);
 			else if (!!(process.env.NODE_ENV !== "production")) warn$1("Invalid VNode type:", type, `(${typeof type})`);
 		}
-		if (ref$1 != null && parentComponent) setRef(ref$1, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
-		else if (ref$1 == null && n1 && n1.ref != null) setRef(n1.ref, null, parentSuspense, n1, true);
+		if (ref != null && parentComponent) setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
+		else if (ref == null && n1 && n1.ref != null) setRef(n1.ref, null, parentSuspense, n1, true);
 	};
 	const processText = (n1, n2, container, anchor) => {
 		if (n1 == null) hostInsert(n2.el = hostCreateText(n2.children), container, anchor);
@@ -3389,7 +4076,15 @@ function baseCreateRenderer(options, createHydrationFns) {
 		if (n2.type === "svg") namespace = "svg";
 		else if (n2.type === "math") namespace = "mathml";
 		if (n1 == null) mountElement(n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-		else patchElement(n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
+		else {
+			const customElement = n1.el && n1.el._isVueCE ? n1.el : null;
+			try {
+				if (customElement) customElement._beginPatch();
+				patchElement(n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
+			} finally {
+				if (customElement) customElement._endPatch();
+			}
+		}
 	};
 	const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
 		let el;
@@ -3517,7 +4212,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 			hostInsert(fragmentStartAnchor, container, anchor);
 			hostInsert(fragmentEndAnchor, container, anchor);
 			mountChildren(n2.children || [], container, fragmentEndAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-		} else if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && n1.dynamicChildren) {
+		} else if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && n1.dynamicChildren && n1.dynamicChildren.length === dynamicChildren.length) {
 			patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, namespace, slotScopeIds);
 			if (!!(process.env.NODE_ENV !== "production")) traverseStaticChildren(n1, n2);
 			else if (n2.key != null || parentComponent && n2 === parentComponent.subTree) traverseStaticChildren(n1, n2, true);
@@ -3593,7 +4288,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 					if (isAsyncWrapperVNode && type.__asyncHydrate) type.__asyncHydrate(el, instance, hydrateSubTree);
 					else hydrateSubTree();
 				} else {
-					if (root.ce && root.ce._def.shadowRoot !== false) root.ce._injectChildStyle(type);
+					if (root.ce && root.ce._hasShadowRoot()) root.ce._injectChildStyle(type, instance.parent ? instance.parent.type : void 0);
 					if (!!(process.env.NODE_ENV !== "production")) startMeasure(instance, `render`);
 					const subTree = instance.subTree = renderComponentRoot(instance);
 					if (!!(process.env.NODE_ENV !== "production")) endMeasure(instance, `render`);
@@ -3621,7 +4316,9 @@ function baseCreateRenderer(options, createHydrationFns) {
 							updateComponentPreRender(instance, next, optimized);
 						}
 						nonHydratedAsyncRoot.asyncDep.then(() => {
-							if (!instance.isUnmounted) componentUpdateFn();
+							queuePostRenderEffect(() => {
+								if (!instance.isUnmounted) update();
+							}, parentSuspense);
 						});
 						return;
 					}
@@ -3654,17 +4351,17 @@ function baseCreateRenderer(options, createHydrationFns) {
 			}
 		};
 		instance.scope.on();
-		const effect$1 = instance.effect = new ReactiveEffect(componentUpdateFn);
+		const effect = instance.effect = new ReactiveEffect(componentUpdateFn);
 		instance.scope.off();
-		const update = instance.update = effect$1.run.bind(effect$1);
-		const job = instance.job = effect$1.runIfDirty.bind(effect$1);
+		const update = instance.update = effect.run.bind(effect);
+		const job = instance.job = effect.runIfDirty.bind(effect);
 		job.i = instance;
 		job.id = instance.uid;
-		effect$1.scheduler = () => queueJob(job);
+		effect.scheduler = () => queueJob(job);
 		toggleRecurse(instance, true);
 		if (!!(process.env.NODE_ENV !== "production")) {
-			effect$1.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
-			effect$1.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
+			effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
+			effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
 		}
 		update();
 	};
@@ -3795,7 +4492,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 				const nextIndex = s2 + i;
 				const nextChild = c2[nextIndex];
 				const anchorVNode = c2[nextIndex + 1];
-				const anchor = nextIndex + 1 < l2 ? anchorVNode.el || anchorVNode.placeholder : parentAnchor;
+				const anchor = nextIndex + 1 < l2 ? anchorVNode.el || resolveAsyncComponentPlaceholder(anchorVNode) : parentAnchor;
 				if (newIndexToOldIndexMap[i] === 0) patch(null, nextChild, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
 				else if (moved) if (j < 0 || i !== increasingNewIndexSequence[j]) move(nextChild, container, anchor, 2);
 				else j--;
@@ -3849,11 +4546,11 @@ function baseCreateRenderer(options, createHydrationFns) {
 		else hostInsert(el, container, anchor);
 	};
 	const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
-		const { type, props, ref: ref$1, children, dynamicChildren, shapeFlag, patchFlag, dirs, cacheIndex } = vnode;
+		const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs, cacheIndex } = vnode;
 		if (patchFlag === -2) optimized = false;
-		if (ref$1 != null) {
+		if (ref != null) {
 			pauseTracking();
-			setRef(ref$1, null, parentSuspense, vnode, true);
+			setRef(ref, null, parentSuspense, vnode, true);
 			resetTracking();
 		}
 		if (cacheIndex != null) parentComponent.renderCache[cacheIndex] = void 0;
@@ -3875,19 +4572,19 @@ function baseCreateRenderer(options, createHydrationFns) {
 			if (shapeFlag & 64) vnode.type.remove(vnode, parentComponent, parentSuspense, internals, doRemove);
 			else if (dynamicChildren && !dynamicChildren.hasOnce && (type !== Fragment || patchFlag > 0 && patchFlag & 64)) unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true);
 			else if (type === Fragment && patchFlag & 384 || !optimized && shapeFlag & 16) unmountChildren(children, parentComponent, parentSuspense);
-			if (doRemove) remove$1(vnode);
+			if (doRemove) remove(vnode);
 		}
 		if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) queuePostRenderEffect(() => {
 			vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
 			shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
 		}, parentSuspense);
 	};
-	const remove$1 = (vnode) => {
+	const remove = (vnode) => {
 		const { type, el, anchor, transition } = vnode;
 		if (type === Fragment) {
 			if (!!(process.env.NODE_ENV !== "production") && vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) vnode.children.forEach((child) => {
 				if (child.type === Comment) hostRemove(child.el);
-				else remove$1(child);
+				else remove(child);
 			});
 			else removeFragment(el, anchor);
 			return;
@@ -3944,14 +4641,18 @@ function baseCreateRenderer(options, createHydrationFns) {
 		return teleportEnd ? hostNextSibling(teleportEnd) : el;
 	};
 	let isFlushing = false;
-	const render$1 = (vnode, container, namespace) => {
+	const render = (vnode, container, namespace) => {
+		let instance;
 		if (vnode == null) {
-			if (container._vnode) unmount(container._vnode, null, null, true);
+			if (container._vnode) {
+				unmount(container._vnode, null, null, true);
+				instance = container._vnode.component;
+			}
 		} else patch(container._vnode || null, vnode, container, null, null, null, namespace);
 		container._vnode = vnode;
 		if (!isFlushing) {
 			isFlushing = true;
-			flushPreFlushCbs();
+			flushPreFlushCbs(instance);
 			flushPostFlushCbs();
 			isFlushing = false;
 		}
@@ -3960,7 +4661,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 		p: patch,
 		um: unmount,
 		m: move,
-		r: remove$1,
+		r: remove,
 		mt: mountComponent,
 		mc: mountChildren,
 		pc: patchChildren,
@@ -3972,20 +4673,20 @@ function baseCreateRenderer(options, createHydrationFns) {
 	let hydrateNode;
 	if (createHydrationFns) [hydrate, hydrateNode] = createHydrationFns(internals);
 	return {
-		render: render$1,
+		render,
 		hydrate,
-		createApp: createAppAPI(render$1, hydrate)
+		createApp: createAppAPI(render, hydrate)
 	};
 }
 function resolveChildrenNamespace({ type, props }, currentNamespace) {
 	return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
 }
-function toggleRecurse({ effect: effect$1, job }, allowed) {
+function toggleRecurse({ effect, job }, allowed) {
 	if (allowed) {
-		effect$1.flags |= 32;
+		effect.flags |= 32;
 		job.flags |= 4;
 	} else {
-		effect$1.flags &= -33;
+		effect.flags &= -33;
 		job.flags &= -5;
 	}
 }
@@ -4005,13 +4706,16 @@ function traverseStaticChildren(n1, n2, shallow = false) {
 			}
 			if (!shallow && c2.patchFlag !== -2) traverseStaticChildren(c1, c2);
 		}
-		if (c2.type === Text && c2.patchFlag !== -1) c2.el = c1.el;
+		if (c2.type === Text) {
+			if (c2.patchFlag === -1) c2 = ch2[i] = cloneIfMounted(c2);
+			c2.el = c1.el;
+		}
 		if (c2.type === Comment && !c2.el) c2.el = c1.el;
 		if (!!(process.env.NODE_ENV !== "production")) c2.el && (c2.el.__vnode = c2);
 	}
 }
 function getSequence(arr) {
-	const p$1 = arr.slice();
+	const p = arr.slice();
 	const result = [0];
 	let i, j, u, v, c;
 	const len = arr.length;
@@ -4020,7 +4724,7 @@ function getSequence(arr) {
 		if (arrI !== 0) {
 			j = result[result.length - 1];
 			if (arr[j] < arrI) {
-				p$1[i] = j;
+				p[i] = j;
 				result.push(i);
 				continue;
 			}
@@ -4032,7 +4736,7 @@ function getSequence(arr) {
 				else v = c;
 			}
 			if (arrI < arr[result[u]]) {
-				if (u > 0) p$1[i] = result[u - 1];
+				if (u > 0) p[i] = result[u - 1];
 				result[u] = i;
 			}
 		}
@@ -4041,7 +4745,7 @@ function getSequence(arr) {
 	v = result[u - 1];
 	while (u-- > 0) {
 		result[u] = v;
-		v = p$1[v];
+		v = p[v];
 	}
 	return result;
 }
@@ -4053,412 +4757,308 @@ function locateNonHydratedAsyncRoot(instance) {
 function invalidateMount(hooks) {
 	if (hooks) for (let i = 0; i < hooks.length; i++) hooks[i].flags |= 8;
 }
-const ssrContextKey = Symbol.for("v-scx");
-const useSSRContext = () => {
-	{
-		const ctx = inject(ssrContextKey);
-		if (!ctx) process.env.NODE_ENV !== "production" && warn$1(`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`);
-		return ctx;
-	}
-};
-function watchEffect(effect$1, options) {
-	return doWatch(effect$1, null, options);
-}
-function watchSyncEffect(effect$1, options) {
-	return doWatch(effect$1, null, !!(process.env.NODE_ENV !== "production") ? extend({}, options, { flush: "sync" }) : { flush: "sync" });
-}
-function watch(source, cb, options) {
-	if (!!(process.env.NODE_ENV !== "production") && !isFunction(cb)) warn$1(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`);
-	return doWatch(source, cb, options);
+function resolveAsyncComponentPlaceholder(anchorVnode) {
+	if (anchorVnode.placeholder) return anchorVnode.placeholder;
+	const instance = anchorVnode.component;
+	if (instance) return resolveAsyncComponentPlaceholder(instance.subTree);
+	return null;
 }
-function doWatch(source, cb, options = EMPTY_OBJ) {
-	const { immediate, deep, flush, once } = options;
-	if (!!(process.env.NODE_ENV !== "production") && !cb) {
-		if (immediate !== void 0) warn$1(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`);
-		if (deep !== void 0) warn$1(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`);
-		if (once !== void 0) warn$1(`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`);
-	}
-	const baseWatchOptions = extend({}, options);
-	if (!!(process.env.NODE_ENV !== "production")) baseWatchOptions.onWarn = warn$1;
-	const runsImmediately = cb && immediate || !cb && flush !== "post";
-	let ssrCleanup;
-	if (isInSSRComponentSetup) {
-		if (flush === "sync") {
-			const ctx = useSSRContext();
-			ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
-		} else if (!runsImmediately) {
-			const watchStopHandle = () => {};
-			watchStopHandle.stop = NOOP;
-			watchStopHandle.resume = NOOP;
-			watchStopHandle.pause = NOOP;
-			return watchStopHandle;
-		}
-	}
-	const instance = currentInstance;
-	baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
-	let isPre = false;
-	if (flush === "post") baseWatchOptions.scheduler = (job) => {
-		queuePostRenderEffect(job, instance && instance.suspense);
-	};
-	else if (flush !== "sync") {
-		isPre = true;
-		baseWatchOptions.scheduler = (job, isFirstRun) => {
-			if (isFirstRun) job();
-			else queueJob(job);
-		};
-	}
-	baseWatchOptions.augmentJob = (job) => {
-		if (cb) job.flags |= 4;
-		if (isPre) {
-			job.flags |= 2;
-			if (instance) {
-				job.id = instance.uid;
-				job.i = instance;
+const isSuspense = (type) => type.__isSuspense;
+let suspenseId = 0;
+const Suspense = {
+	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) {
+				n2.suspense = n1.suspense;
+				n2.suspense.vnode = n2;
+				n2.el = n1.el;
+				return;
 			}
+			patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, rendererInternals);
 		}
-	};
-	const watchHandle = watch$1(source, cb, baseWatchOptions);
-	if (isInSSRComponentSetup) {
-		if (ssrCleanup) ssrCleanup.push(watchHandle);
-		else if (runsImmediately) watchHandle();
-	}
-	return watchHandle;
-}
-function instanceWatch(source, value, options) {
-	const publicThis = this.proxy;
-	const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
-	let cb;
-	if (isFunction(value)) cb = value;
-	else {
-		cb = value.handler;
-		options = value;
-	}
-	const reset = setCurrentInstance(this);
-	const res = doWatch(getter, cb.bind(publicThis), options);
-	reset();
-	return res;
-}
-function createPathGetter(ctx, path) {
-	const segments = path.split(".");
-	return () => {
-		let cur = ctx;
-		for (let i = 0; i < segments.length && cur; i++) cur = cur[segments[i]];
-		return cur;
-	};
-}
-function useModel(props, name, options = EMPTY_OBJ) {
-	const i = getCurrentInstance();
-	if (!!(process.env.NODE_ENV !== "production") && !i) {
-		warn$1(`useModel() called without active instance.`);
-		return ref();
-	}
-	const camelizedName = camelize$1(name);
-	if (!!(process.env.NODE_ENV !== "production") && !i.propsOptions[0][camelizedName]) {
-		warn$1(`useModel() called with prop "${name}" which is not declared.`);
-		return ref();
-	}
-	const hyphenatedName = hyphenate$1(name);
-	const modifiers = getModelModifiers(props, camelizedName);
-	const res = customRef((track$1, trigger$1) => {
-		let localValue;
-		let prevSetValue = EMPTY_OBJ;
-		let prevEmittedValue;
-		watchSyncEffect(() => {
-			const propValue = props[camelizedName];
-			if (hasChanged(localValue, propValue)) {
-				localValue = propValue;
-				trigger$1();
-			}
-		});
-		return {
-			get() {
-				track$1();
-				return options.get ? options.get(localValue) : localValue;
-			},
-			set(value) {
-				const emittedValue = options.set ? options.set(value) : value;
-				if (!hasChanged(emittedValue, localValue) && !(prevSetValue !== EMPTY_OBJ && hasChanged(value, prevSetValue))) return;
-				const rawProps = i.vnode.props;
-				if (!(rawProps && (name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) {
-					localValue = value;
-					trigger$1();
+	},
+	hydrate: hydrateSuspense,
+	normalize: normalizeSuspenseChildren
+};
+function triggerEvent(vnode, name) {
+	const eventListener = vnode.props && vnode.props[name];
+	if (isFunction(eventListener)) eventListener();
+}
+function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
+	const { p: patch, o: { createElement } } = rendererInternals;
+	const hiddenContainer = createElement("div");
+	const suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals);
+	patch(null, suspense.pendingBranch = vnode.ssContent, hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds);
+	if (suspense.deps > 0) {
+		triggerEvent(vnode, "onPending");
+		triggerEvent(vnode, "onFallback");
+		patch(null, vnode.ssFallback, container, anchor, parentComponent, null, namespace, slotScopeIds);
+		setActiveBranch(suspense, vnode.ssFallback);
+	} else suspense.resolve(false, true);
+}
+function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+	const suspense = n2.suspense = n1.suspense;
+	suspense.vnode = n2;
+	n2.el = n1.el;
+	const newBranch = n2.ssContent;
+	const newFallback = n2.ssFallback;
+	const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+	if (pendingBranch) {
+		suspense.pendingBranch = newBranch;
+		if (isSameVNodeType(pendingBranch, newBranch)) {
+			patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
+			if (suspense.deps <= 0) suspense.resolve();
+			else if (isInFallback) {
+				if (!isHydrating) {
+					patch(activeBranch, newFallback, container, anchor, parentComponent, null, namespace, slotScopeIds, optimized);
+					setActiveBranch(suspense, newFallback);
 				}
-				i.emit(`update:${name}`, emittedValue);
-				if (hasChanged(value, emittedValue) && hasChanged(value, prevSetValue) && !hasChanged(emittedValue, prevEmittedValue)) trigger$1();
-				prevSetValue = value;
-				prevEmittedValue = emittedValue;
 			}
-		};
-	});
-	res[Symbol.iterator] = () => {
-		let i2 = 0;
-		return { next() {
-			if (i2 < 2) return {
-				value: i2++ ? modifiers || EMPTY_OBJ : res,
-				done: false
-			};
-			else return { done: true };
-		} };
-	};
-	return res;
-}
-const getModelModifiers = (props, modelName) => {
-	return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize$1(modelName)}Modifiers`] || props[`${hyphenate$1(modelName)}Modifiers`];
-};
-function emit(instance, event, ...rawArgs) {
-	if (instance.isUnmounted) return;
-	const props = instance.vnode.props || EMPTY_OBJ;
-	if (!!(process.env.NODE_ENV !== "production")) {
-		const { emitsOptions, propsOptions: [propsOptions] } = instance;
-		if (emitsOptions) if (!(event in emitsOptions) && true) {
-			if (!propsOptions || !(toHandlerKey(camelize$1(event)) in propsOptions)) warn$1(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(camelize$1(event))}" prop.`);
 		} else {
-			const validator = emitsOptions[event];
-			if (isFunction(validator)) {
-				if (!validator(...rawArgs)) warn$1(`Invalid event arguments: event validation failed for event "${event}".`);
+			suspense.pendingId = suspenseId++;
+			if (isHydrating) {
+				suspense.isHydrating = false;
+				suspense.activeBranch = pendingBranch;
+			} else unmount(pendingBranch, parentComponent, suspense);
+			suspense.deps = 0;
+			suspense.effects.length = 0;
+			suspense.hiddenContainer = createElement("div");
+			if (isInFallback) {
+				patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
+				if (suspense.deps <= 0) suspense.resolve();
+				else {
+					patch(activeBranch, newFallback, container, anchor, parentComponent, null, namespace, slotScopeIds, optimized);
+					setActiveBranch(suspense, newFallback);
+				}
+			} else if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
+				patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, namespace, slotScopeIds, optimized);
+				suspense.resolve(true);
+			} else {
+				patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
+				if (suspense.deps <= 0) suspense.resolve();
 			}
 		}
-	}
-	let args = rawArgs;
-	const isModelListener$1 = event.startsWith("update:");
-	const modifiers = isModelListener$1 && getModelModifiers(props, event.slice(7));
-	if (modifiers) {
-		if (modifiers.trim) args = rawArgs.map((a) => isString(a) ? a.trim() : a);
-		if (modifiers.number) args = rawArgs.map(looseToNumber);
-	}
-	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsComponentEmit(instance, event, args);
-	if (!!(process.env.NODE_ENV !== "production")) {
-		const lowerCaseEvent = event.toLowerCase();
-		if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) warn$1(`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate$1(event)}" instead of "${event}".`);
-	}
-	let handlerName;
-	let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize$1(event))];
-	if (!handler && isModelListener$1) handler = props[handlerName = toHandlerKey(hyphenate$1(event))];
-	if (handler) callWithAsyncErrorHandling(handler, instance, 6, args);
-	const onceHandler = props[handlerName + `Once`];
-	if (onceHandler) {
-		if (!instance.emitted) instance.emitted = {};
-		else if (instance.emitted[handlerName]) return;
-		instance.emitted[handlerName] = true;
-		callWithAsyncErrorHandling(onceHandler, instance, 6, args);
+	} else if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
+		patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, namespace, slotScopeIds, optimized);
+		setActiveBranch(suspense, newBranch);
+	} else {
+		triggerEvent(n2, "onPending");
+		suspense.pendingBranch = newBranch;
+		if (newBranch.shapeFlag & 512) suspense.pendingId = newBranch.component.suspenseId;
+		else 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);
+			}, timeout);
+			else if (timeout === 0) suspense.fallback(newFallback);
+		}
 	}
 }
-const mixinEmitsCache = /* @__PURE__ */ new WeakMap();
-function normalizeEmitsOptions(comp, appContext, asMixin = false) {
-	const cache = __VUE_OPTIONS_API__ && asMixin ? mixinEmitsCache : appContext.emitsCache;
-	const cached = cache.get(comp);
-	if (cached !== void 0) return cached;
-	const raw = comp.emits;
-	let normalized = {};
-	let hasExtends = false;
-	if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
-		const extendEmits = (raw2) => {
-			const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
-			if (normalizedFromExtend) {
-				hasExtends = true;
-				extend(normalized, normalizedFromExtend);
-			}
-		};
-		if (!asMixin && appContext.mixins.length) appContext.mixins.forEach(extendEmits);
-		if (comp.extends) extendEmits(comp.extends);
-		if (comp.mixins) comp.mixins.forEach(extendEmits);
-	}
-	if (!raw && !hasExtends) {
-		if (isObject$1(comp)) cache.set(comp, null);
-		return null;
+let hasWarned = false;
+function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+	if (!!(process.env.NODE_ENV !== "production") && !hasWarned) {
+		hasWarned = true;
+		console[console.info ? "info" : "log"](`<Suspense> is an experimental feature and its API will likely change.`);
 	}
-	if (isArray(raw)) raw.forEach((key) => normalized[key] = null);
-	else extend(normalized, raw);
-	if (isObject$1(comp)) cache.set(comp, normalized);
-	return normalized;
-}
-function isEmitListener(options, key) {
-	if (!options || !isOn(key)) return false;
-	key = key.slice(2).replace(/Once$/, "");
-	return hasOwn$1(options, key[0].toLowerCase() + key.slice(1)) || hasOwn$1(options, hyphenate$1(key)) || hasOwn$1(options, key);
-}
-let accessedAttrs = false;
-function markAttrsAccessed() {
-	accessedAttrs = true;
-}
-function renderComponentRoot(instance) {
-	const { type: Component, vnode, proxy, withProxy, propsOptions: [propsOptions], slots, attrs, emit: emit$2, render: render$1, renderCache, props, data, setupState, ctx, inheritAttrs } = instance;
-	const prev = setCurrentRenderingInstance(instance);
-	let result;
-	let fallthroughAttrs;
-	if (!!(process.env.NODE_ENV !== "production")) accessedAttrs = false;
-	try {
-		if (vnode.shapeFlag & 4) {
-			const proxyToUse = withProxy || proxy;
-			const thisProxy = !!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup ? new Proxy(proxyToUse, { get(target, key, receiver) {
-				warn$1(`Property '${String(key)}' was accessed via 'this'. Avoid using 'this' in templates.`);
-				return Reflect.get(target, key, receiver);
-			} }) : proxyToUse;
-			result = normalizeVNode(render$1.call(thisProxy, proxyToUse, renderCache, !!(process.env.NODE_ENV !== "production") ? shallowReadonly(props) : props, setupState, data, ctx));
-			fallthroughAttrs = attrs;
-		} else {
-			const render2 = Component;
-			if (!!(process.env.NODE_ENV !== "production") && attrs === props) markAttrsAccessed();
-			result = normalizeVNode(render2.length > 1 ? render2(!!(process.env.NODE_ENV !== "production") ? shallowReadonly(props) : props, !!(process.env.NODE_ENV !== "production") ? {
-				get attrs() {
-					markAttrsAccessed();
-					return shallowReadonly(attrs);
-				},
-				slots,
-				emit: emit$2
-			} : {
-				attrs,
-				slots,
-				emit: emit$2
-			}) : render2(!!(process.env.NODE_ENV !== "production") ? shallowReadonly(props) : props, null));
-			fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
+	const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove } } = rendererInternals;
+	let parentSuspenseId;
+	const isSuspensible = isVNodeSuspensible(vnode);
+	if (isSuspensible) {
+		if (parentSuspense && parentSuspense.pendingBranch) {
+			parentSuspenseId = parentSuspense.pendingId;
+			parentSuspense.deps++;
 		}
-	} catch (err) {
-		blockStack.length = 0;
-		handleError(err, instance, 1);
-		result = createVNode(Comment);
 	}
-	let root = result;
-	let setRoot = void 0;
-	if (!!(process.env.NODE_ENV !== "production") && result.patchFlag > 0 && result.patchFlag & 2048) [root, setRoot] = getChildRoot(result);
-	if (fallthroughAttrs && inheritAttrs !== false) {
-		const keys = Object.keys(fallthroughAttrs);
-		const { shapeFlag } = root;
-		if (keys.length) {
-			if (shapeFlag & 7) {
-				if (propsOptions && keys.some(isModelListener)) fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
-				root = cloneVNode(root, fallthroughAttrs, false, true);
-			} else if (!!(process.env.NODE_ENV !== "production") && !accessedAttrs && root.type !== Comment) {
-				const allAttrs = Object.keys(attrs);
-				const eventAttrs = [];
-				const extraAttrs = [];
-				for (let i = 0, l = allAttrs.length; i < l; i++) {
-					const key = allAttrs[i];
-					if (isOn(key)) {
-						if (!isModelListener(key)) eventAttrs.push(key[2].toLowerCase() + key.slice(3));
-					} else extraAttrs.push(key);
+	const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
+	if (!!(process.env.NODE_ENV !== "production")) assertNumber(timeout, `Suspense timeout`);
+	const initialAnchor = anchor;
+	const suspense = {
+		vnode,
+		parent: parentSuspense,
+		parentComponent,
+		namespace,
+		container,
+		hiddenContainer,
+		deps: 0,
+		pendingId: suspenseId++,
+		timeout: typeof timeout === "number" ? timeout : -1,
+		activeBranch: null,
+		pendingBranch: null,
+		isInFallback: !isHydrating,
+		isHydrating,
+		isUnmounted: false,
+		effects: [],
+		resolve(resume = false, sync = false) {
+			if (!!(process.env.NODE_ENV !== "production")) {
+				if (!resume && !suspense.pendingBranch) throw new Error(`suspense.resolve() is called without a pending branch.`);
+				if (suspense.isUnmounted) throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`);
+			}
+			const { vnode: vnode2, activeBranch, pendingBranch, pendingId, effects, parentComponent: parentComponent2, container: container2, isInFallback } = suspense;
+			let delayEnter = false;
+			if (suspense.isHydrating) suspense.isHydrating = false;
+			else if (!resume) {
+				delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
+				if (delayEnter) activeBranch.transition.afterLeave = () => {
+					if (pendingId === suspense.pendingId) {
+						move(pendingBranch, container2, anchor === initialAnchor ? next(activeBranch) : anchor, 0);
+						queuePostFlushCb(effects);
+						if (isInFallback && vnode2.ssFallback) vnode2.ssFallback.el = null;
+					}
+				};
+				if (activeBranch) {
+					if (parentNode(activeBranch.el) === container2) anchor = next(activeBranch);
+					unmount(activeBranch, parentComponent2, suspense, true);
+					if (!delayEnter && isInFallback && vnode2.ssFallback) queuePostRenderEffect(() => vnode2.ssFallback.el = null, suspense);
 				}
-				if (extraAttrs.length) warn$1(`Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text or teleport root nodes.`);
-				if (eventAttrs.length) warn$1(`Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`);
+				if (!delayEnter) move(pendingBranch, container2, anchor, 0);
 			}
-		}
-	}
-	if (vnode.dirs) {
-		if (!!(process.env.NODE_ENV !== "production") && !isElementRoot(root)) warn$1(`Runtime directive used on component with non-element root node. The directives will not function as intended.`);
-		root = cloneVNode(root, null, false, true);
-		root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
-	}
-	if (vnode.transition) {
-		if (!!(process.env.NODE_ENV !== "production") && !isElementRoot(root)) warn$1(`Component inside <Transition> renders non-element root node that cannot be animated.`);
-		setTransitionHooks(root, vnode.transition);
-	}
-	if (!!(process.env.NODE_ENV !== "production") && setRoot) setRoot(root);
-	else result = root;
-	setCurrentRenderingInstance(prev);
-	return result;
-}
-const getChildRoot = (vnode) => {
-	const rawChildren = vnode.children;
-	const dynamicChildren = vnode.dynamicChildren;
-	const childRoot = filterSingleRoot(rawChildren, false);
-	if (!childRoot) return [vnode, void 0];
-	else if (!!(process.env.NODE_ENV !== "production") && childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) return getChildRoot(childRoot);
-	const index = rawChildren.indexOf(childRoot);
-	const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
-	const setRoot = (updatedRoot) => {
-		rawChildren[index] = updatedRoot;
-		if (dynamicChildren) {
-			if (dynamicIndex > -1) dynamicChildren[dynamicIndex] = updatedRoot;
-			else if (updatedRoot.patchFlag > 0) vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
-		}
-	};
-	return [normalizeVNode(childRoot), setRoot];
-};
-function filterSingleRoot(children, recurse = true) {
-	let singleRoot;
-	for (let i = 0; i < children.length; i++) {
-		const child = children[i];
-		if (isVNode(child)) {
-			if (child.type !== Comment || child.children === "v-if") if (singleRoot) return;
-			else {
-				singleRoot = child;
-				if (!!(process.env.NODE_ENV !== "production") && recurse && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) return filterSingleRoot(singleRoot.children);
+			setActiveBranch(suspense, pendingBranch);
+			suspense.pendingBranch = null;
+			suspense.isInFallback = false;
+			let parent = suspense.parent;
+			let hasUnresolvedAncestor = false;
+			while (parent) {
+				if (parent.pendingBranch) {
+					parent.effects.push(...effects);
+					hasUnresolvedAncestor = true;
+					break;
+				}
+				parent = parent.parent;
 			}
-		} else return;
-	}
-	return singleRoot;
-}
-const getFunctionalFallthrough = (attrs) => {
-	let res;
-	for (const key in attrs) if (key === "class" || key === "style" || isOn(key)) (res || (res = {}))[key] = attrs[key];
-	return res;
-};
-const filterModelListeners = (attrs, props) => {
-	const res = {};
-	for (const key in attrs) if (!isModelListener(key) || !(key.slice(9) in props)) res[key] = attrs[key];
-	return res;
-};
-const isElementRoot = (vnode) => {
-	return vnode.shapeFlag & 7 || vnode.type === Comment;
-};
-function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
-	const { props: prevProps, children: prevChildren, component } = prevVNode;
-	const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
-	const emits = component.emitsOptions;
-	if (!!(process.env.NODE_ENV !== "production") && (prevChildren || nextChildren) && isHmrUpdating) return true;
-	if (nextVNode.dirs || nextVNode.transition) return true;
-	if (optimized && patchFlag >= 0) {
-		if (patchFlag & 1024) return true;
-		if (patchFlag & 16) {
-			if (!prevProps) return !!nextProps;
-			return hasPropsChanged(prevProps, nextProps, emits);
-		} else if (patchFlag & 8) {
-			const dynamicProps = nextVNode.dynamicProps;
-			for (let i = 0; i < dynamicProps.length; i++) {
-				const key = dynamicProps[i];
-				if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) return true;
+			if (!hasUnresolvedAncestor && !delayEnter) queuePostFlushCb(effects);
+			suspense.effects = [];
+			if (isSuspensible) {
+				if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+					parentSuspense.deps--;
+					if (parentSuspense.deps === 0 && !sync) parentSuspense.resolve();
+				}
 			}
+			triggerEvent(vnode2, "onResolve");
+		},
+		fallback(fallbackVNode) {
+			if (!suspense.pendingBranch) return;
+			const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
+			triggerEvent(vnode2, "onFallback");
+			const anchor2 = next(activeBranch);
+			const mountFallback = () => {
+				if (!suspense.isInFallback) return;
+				patch(null, fallbackVNode, container2, anchor2, parentComponent2, null, namespace2, slotScopeIds, optimized);
+				setActiveBranch(suspense, fallbackVNode);
+			};
+			const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
+			if (delayEnter) activeBranch.transition.afterLeave = mountFallback;
+			suspense.isInFallback = true;
+			unmount(activeBranch, parentComponent2, null, true);
+			if (!delayEnter) mountFallback();
+		},
+		move(container2, anchor2, type) {
+			suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+			suspense.container = container2;
+		},
+		next() {
+			return suspense.activeBranch && next(suspense.activeBranch);
+		},
+		registerDep(instance, setupRenderEffect, optimized2) {
+			const isInPendingSuspense = !!suspense.pendingBranch;
+			if (isInPendingSuspense) suspense.deps++;
+			const hydratedEl = instance.vnode.el;
+			instance.asyncDep.catch((err) => {
+				handleError(err, instance, 0);
+			}).then((asyncSetupResult) => {
+				if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) return;
+				instance.asyncResolved = true;
+				const { vnode: vnode2 } = instance;
+				if (!!(process.env.NODE_ENV !== "production")) pushWarningContext(vnode2);
+				handleSetupResult(instance, asyncSetupResult, false);
+				if (hydratedEl) vnode2.el = hydratedEl;
+				const placeholder = !hydratedEl && instance.subTree.el;
+				setupRenderEffect(instance, vnode2, parentNode(hydratedEl || instance.subTree.el), hydratedEl ? null : next(instance.subTree), suspense, namespace, optimized2);
+				if (placeholder) {
+					vnode2.placeholder = null;
+					remove(placeholder);
+				}
+				updateHOCHostEl(instance, vnode2.el);
+				if (!!(process.env.NODE_ENV !== "production")) popWarningContext();
+				if (isInPendingSuspense && --suspense.deps === 0) suspense.resolve();
+			});
+		},
+		unmount(parentSuspense2, doRemove) {
+			suspense.isUnmounted = true;
+			if (suspense.activeBranch) unmount(suspense.activeBranch, parentComponent, parentSuspense2, doRemove);
+			if (suspense.pendingBranch) unmount(suspense.pendingBranch, parentComponent, parentSuspense2, doRemove);
 		}
-	} else {
-		if (prevChildren || nextChildren) {
-			if (!nextChildren || !nextChildren.$stable) return true;
-		}
-		if (prevProps === nextProps) return false;
-		if (!prevProps) return !!nextProps;
-		if (!nextProps) return true;
-		return hasPropsChanged(prevProps, nextProps, emits);
-	}
-	return false;
+	};
+	return suspense;
 }
-function hasPropsChanged(prevProps, nextProps, emitsOptions) {
-	const nextKeys = Object.keys(nextProps);
-	if (nextKeys.length !== Object.keys(prevProps).length) return true;
-	for (let i = 0; i < nextKeys.length; i++) {
-		const key = nextKeys[i];
-		if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) return true;
-	}
-	return false;
+function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+	const suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement("div"), null, namespace, slotScopeIds, optimized, rendererInternals, true);
+	const result = hydrateNode(node, suspense.pendingBranch = vnode.ssContent, parentComponent, suspense, slotScopeIds, optimized);
+	if (suspense.deps === 0) suspense.resolve(false, true);
+	return result;
 }
-function updateHOCHostEl({ vnode, parent }, el) {
-	while (parent) {
-		const root = parent.subTree;
-		if (root.suspense && root.suspense.activeBranch === vnode) root.el = vnode.el;
-		if (root === vnode) {
-			(vnode = parent.vnode).el = el;
-			parent = parent.parent;
-		} else break;
+function normalizeSuspenseChildren(vnode) {
+	const { shapeFlag, children } = vnode;
+	const isSlotChildren = shapeFlag & 32;
+	vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children);
+	vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
+}
+function normalizeSuspenseSlot(s) {
+	let block;
+	if (isFunction(s)) {
+		const trackBlock = isBlockTreeEnabled && s._c;
+		if (trackBlock) {
+			s._d = false;
+			openBlock();
+		}
+		s = s();
+		if (trackBlock) {
+			s._d = true;
+			block = currentBlock;
+			closeBlock();
+		}
 	}
+	if (isArray(s)) {
+		const singleChild = filterSingleRoot(s);
+		if (!!(process.env.NODE_ENV !== "production") && !singleChild && s.filter((child) => child !== NULL_DYNAMIC_COMPONENT).length > 0) warn$1(`<Suspense> slots expect a single root node.`);
+		s = singleChild;
+	}
+	s = normalizeVNode(s);
+	if (block && !s.dynamicChildren) s.dynamicChildren = block.filter((c) => c !== s);
+	return s;
 }
-const isSuspense = (type) => type.__isSuspense;
 function queueEffectWithSuspense(fn, suspense) {
 	if (suspense && suspense.pendingBranch) if (isArray(fn)) suspense.effects.push(...fn);
 	else suspense.effects.push(fn);
 	else queuePostFlushCb(fn);
 }
-const Fragment = Symbol.for("v-fgt");
-const Text = Symbol.for("v-txt");
-const Comment = Symbol.for("v-cmt");
-const Static = Symbol.for("v-stc");
+function setActiveBranch(suspense, branch) {
+	suspense.activeBranch = branch;
+	const { vnode, parentComponent } = suspense;
+	let el = branch.el;
+	while (!el && branch.component) {
+		branch = branch.component.subTree;
+		el = branch.el;
+	}
+	vnode.el = el;
+	if (parentComponent && parentComponent.subTree === vnode) {
+		parentComponent.vnode.el = el;
+		updateHOCHostEl(parentComponent, el);
+	}
+}
+function isVNodeSuspensible(vnode) {
+	const suspensible = vnode.props && vnode.props.suspensible;
+	return suspensible != null && suspensible !== false;
+}
+const Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
+const Text = /* @__PURE__ */ Symbol.for("v-txt");
+const Comment = /* @__PURE__ */ Symbol.for("v-cmt");
+const Static = /* @__PURE__ */ Symbol.for("v-stc");
 const blockStack = [];
 let currentBlock = null;
 function openBlock(disableTracking = false) {
@@ -4499,19 +5099,18 @@ function isSameVNodeType(n1, n2) {
 	}
 	return n1.type === n2.type && n1.key === n2.key;
 }
-let vnodeArgsTransformer;
 const createVNodeWithArgsTransform = (...args) => {
-	return _createVNode(...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args);
+	return _createVNode(...args);
 };
 const normalizeKey = ({ key }) => key != null ? key : null;
-const normalizeRef = ({ ref: ref$1, ref_key, ref_for }) => {
-	if (typeof ref$1 === "number") ref$1 = "" + ref$1;
-	return ref$1 != null ? isString(ref$1) || isRef(ref$1) || isFunction(ref$1) ? {
+const normalizeRef = ({ ref, ref_key, ref_for }) => {
+	if (typeof ref === "number") ref = "" + ref;
+	return ref != null ? isString(ref) || /* @__PURE__ */ isRef(ref) || isFunction(ref) ? {
 		i: currentRenderingInstance,
-		r: ref$1,
+		r: ref,
 		k: ref_key,
 		f: !!ref_for
-	} : ref$1 : null;
+	} : ref : null;
 };
 function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
 	const vnode = {
@@ -4571,13 +5170,13 @@ function _createVNode(type, props = null, children = null, patchFlag = 0, dynami
 		let { class: klass, style } = props;
 		if (klass && !isString(klass)) props.class = normalizeClass(klass);
 		if (isObject$1(style)) {
-			if (isProxy(style) && !isArray(style)) style = extend({}, style);
+			if (/* @__PURE__ */ isProxy(style) && !isArray(style)) style = extend({}, style);
 			props.style = normalizeStyle(style);
 		}
 	}
 	const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject$1(type) ? 4 : isFunction(type) ? 2 : 0;
-	if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
-		type = toRaw(type);
+	if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && /* @__PURE__ */ isProxy(type)) {
+		type = /* @__PURE__ */ toRaw(type);
 		warn$1(`Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`, `
 Component that was made reactive: `, type);
 	}
@@ -4585,10 +5184,10 @@ Component that was made reactive: `, type);
 }
 function guardReactiveProps(props) {
 	if (!props) return null;
-	return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+	return /* @__PURE__ */ isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
 }
 function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
-	const { props, ref: ref$1, patchFlag, children, transition } = vnode;
+	const { props, ref, patchFlag, children, transition } = vnode;
 	const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
 	const cloned = {
 		__v_isVNode: true,
@@ -4596,7 +5195,7 @@ function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false
 		type: vnode.type,
 		props: mergedProps,
 		key: mergedProps && normalizeKey(mergedProps),
-		ref: extraProps && extraProps.ref ? mergeRef && ref$1 ? isArray(ref$1) ? ref$1.concat(normalizeRef(extraProps)) : [ref$1, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref$1,
+		ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
 		scopeId: vnode.scopeId,
 		slotScopeIds: vnode.slotScopeIds,
 		children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
@@ -4632,6 +5231,11 @@ function deepCloneVNode(vnode) {
 function createTextVNode(text = " ", flag = 0) {
 	return createVNode(Text, null, text, flag);
 }
+function createStaticVNode(content, numberOfNodes) {
+	const vnode = createVNode(Static, null, content);
+	vnode.staticCount = numberOfNodes;
+	return vnode;
+}
 function createCommentVNode(text = "", asBlock = false) {
 	return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
 }
@@ -4827,7 +5431,6 @@ function setupComponent(instance, isSSR = false, optimized = false) {
 	return setupResult;
 }
 function setupStatefulComponent(instance, isSSR) {
-	var _a;
 	const Component = instance.type;
 	if (!!(process.env.NODE_ENV !== "production")) {
 		if (Component.name) validateComponentName(Component.name, instance.appContext.config);
@@ -4849,7 +5452,7 @@ function setupStatefulComponent(instance, isSSR) {
 		pauseTracking();
 		const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
 		const reset = setCurrentInstance(instance);
-		const setupResult = callWithErrorHandling(setup, instance, 0, [!!(process.env.NODE_ENV !== "production") ? shallowReadonly(instance.props) : instance.props, setupContext]);
+		const setupResult = callWithErrorHandling(setup, instance, 0, [!!(process.env.NODE_ENV !== "production") ? /* @__PURE__ */ shallowReadonly(instance.props) : instance.props, setupContext]);
 		const isAsyncSetup = isPromise(setupResult);
 		resetTracking();
 		reset();
@@ -4863,7 +5466,7 @@ function setupStatefulComponent(instance, isSSR) {
 			});
 			else {
 				instance.asyncDep = setupResult;
-				if (!!(process.env.NODE_ENV !== "production") && !instance.suspense) warn$1(`Component <${(_a = Component.name) != null ? _a : "Anonymous"}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`);
+				if (!!(process.env.NODE_ENV !== "production") && !instance.suspense) warn$1(`Component <${formatComponentName(instance, Component)}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`);
 			}
 		} else handleSetupResult(instance, setupResult, isSSR);
 	} else finishComponentSetup(instance, isSSR);
@@ -4879,29 +5482,10 @@ function handleSetupResult(instance, setupResult, isSSR) {
 	} else if (!!(process.env.NODE_ENV !== "production") && setupResult !== void 0) warn$1(`setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`);
 	finishComponentSetup(instance, isSSR);
 }
-let compile;
-let installWithProxy;
-const isRuntimeOnly = () => !compile;
+const isRuntimeOnly = () => true;
 function finishComponentSetup(instance, isSSR, skipOptions) {
 	const Component = instance.type;
-	if (!instance.render) {
-		if (!isSSR && compile && !Component.render) {
-			const template = Component.template || __VUE_OPTIONS_API__ && resolveMergedOptions(instance).template;
-			if (template) {
-				if (!!(process.env.NODE_ENV !== "production")) startMeasure(instance, `compile`);
-				const { isCustomElement, compilerOptions } = instance.appContext.config;
-				const { delimiters, compilerOptions: componentCompilerOptions } = Component;
-				const finalCompilerOptions = extend(extend({
-					isCustomElement,
-					delimiters
-				}, compilerOptions), componentCompilerOptions);
-				Component.render = compile(template, finalCompilerOptions);
-				if (!!(process.env.NODE_ENV !== "production")) endMeasure(instance, `compile`);
-			}
-		}
-		instance.render = Component.render || NOOP;
-		if (installWithProxy) installWithProxy(instance);
-	}
+	if (!instance.render) instance.render = Component.render || NOOP;
 	if (__VUE_OPTIONS_API__ && true) {
 		const reset = setCurrentInstance(instance);
 		pauseTracking();
@@ -4912,7 +5496,7 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
 			reset();
 		}
 	}
-	if (!!(process.env.NODE_ENV !== "production") && !Component.render && instance.render === NOOP && !isSSR) if (!compile && Component.template) warn$1("Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias \"vue\" to \"vue/dist/vue.esm-bundler.js\".");
+	if (!!(process.env.NODE_ENV !== "production") && !Component.render && instance.render === NOOP && !isSSR) if (Component.template) warn$1("Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias \"vue\" to \"vue/dist/vue.esm-bundler.js\".");
 	else warn$1(`Component is missing template or render function: `, Component);
 }
 const attrsProxyHandlers = !!(process.env.NODE_ENV !== "production") ? {
@@ -4947,7 +5531,7 @@ function createSetupContext(instance) {
 				let exposedType = typeof exposed;
 				if (exposedType === "object") {
 					if (isArray(exposed)) exposedType = "array";
-					else if (isRef(exposed)) exposedType = "ref";
+					else if (/* @__PURE__ */ isRef(exposed)) exposedType = "ref";
 				}
 				if (exposedType !== "object") warn$1(`expose() should be passed a plain object, received ${exposedType}.`);
 			}
@@ -4999,11 +5583,11 @@ function formatComponentName(instance, Component, isRoot = false) {
 		const match = Component.__file.match(/([^/\\]+)\.\w+$/);
 		if (match) name = match[1];
 	}
-	if (!name && instance && instance.parent) {
+	if (!name && instance) {
 		const inferFromRegistry = (registry) => {
 			for (const key in registry) if (registry[key] === Component) return key;
 		};
-		name = inferFromRegistry(instance.components || instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
+		name = inferFromRegistry(instance.components) || instance.parent && inferFromRegistry(instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
 	}
 	return name ? classify(name) : isRoot ? `App` : `Anonymous`;
 }
@@ -5011,13 +5595,30 @@ function isClassComponent(value) {
 	return isFunction(value) && "__vccOpts" in value;
 }
 const computed = (getterOrOptions, debugOptions) => {
-	const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+	const c = /* @__PURE__ */ computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
 	if (!!(process.env.NODE_ENV !== "production")) {
 		const i = getCurrentInstance();
 		if (i && i.appContext.config.warnRecursiveComputed) c._warnRecursive = true;
 	}
 	return c;
 };
+function h(type, propsOrChildren, children) {
+	try {
+		setBlockTracking(-1);
+		const l = arguments.length;
+		if (l === 2) if (isObject$1(propsOrChildren) && !isArray(propsOrChildren)) {
+			if (isVNode(propsOrChildren)) return createVNode(type, null, [propsOrChildren]);
+			return createVNode(type, propsOrChildren);
+		} else return createVNode(type, null, propsOrChildren);
+		else {
+			if (l > 3) children = Array.prototype.slice.call(arguments, 2);
+			else if (l === 3 && isVNode(children)) children = [children];
+			return createVNode(type, propsOrChildren, children);
+		}
+	} finally {
+		setBlockTracking(1);
+	}
+}
 function initCustomFormatter() {
 	if (!!!(process.env.NODE_ENV !== "production") || typeof window === "undefined") return;
 	const vueStyle = { style: "color:#3ba776" };
@@ -5033,7 +5634,7 @@ function initCustomFormatter() {
 				vueStyle,
 				`VueInstance`
 			];
-			else if (isRef(obj)) {
+			else if (/* @__PURE__ */ isRef(obj)) {
 				pauseTracking();
 				const value = obj.value;
 				resetTracking();
@@ -5049,25 +5650,25 @@ function initCustomFormatter() {
 					formatValue(value),
 					`>`
 				];
-			} else if (isReactive(obj)) return [
+			} else if (/* @__PURE__ */ isReactive(obj)) return [
 				"div",
 				{},
 				[
 					"span",
 					vueStyle,
-					isShallow(obj) ? "ShallowReactive" : "Reactive"
+					/* @__PURE__ */ isShallow(obj) ? "ShallowReactive" : "Reactive"
 				],
 				"<",
 				formatValue(obj),
-				`>${isReadonly(obj) ? ` (readonly)` : ``}`
+				`>${/* @__PURE__ */ isReadonly(obj) ? ` (readonly)` : ``}`
 			];
-			else if (isReadonly(obj)) return [
+			else if (/* @__PURE__ */ isReadonly(obj)) return [
 				"div",
 				{},
 				[
 					"span",
 					vueStyle,
-					isShallow(obj) ? "ShallowReadonly" : "Readonly"
+					/* @__PURE__ */ isShallow(obj) ? "ShallowReadonly" : "Readonly"
 				],
 				"<",
 				formatValue(obj),
@@ -5088,11 +5689,11 @@ function initCustomFormatter() {
 	};
 	function formatInstance(instance) {
 		const blocks = [];
-		if (instance.type.props && instance.props) blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+		if (instance.type.props && instance.props) blocks.push(createInstanceBlock("props", /* @__PURE__ */ toRaw(instance.props)));
 		if (instance.setupState !== EMPTY_OBJ) blocks.push(createInstanceBlock("setup", instance.setupState));
-		if (instance.data !== EMPTY_OBJ) blocks.push(createInstanceBlock("data", toRaw(instance.data)));
-		const computed$2 = extractKeys(instance, "computed");
-		if (computed$2) blocks.push(createInstanceBlock("computed", computed$2));
+		if (instance.data !== EMPTY_OBJ) blocks.push(createInstanceBlock("data", /* @__PURE__ */ toRaw(instance.data)));
+		const computed = extractKeys(instance, "computed");
+		if (computed) blocks.push(createInstanceBlock("computed", computed));
 		const injected = extractKeys(instance, "inject");
 		if (injected) blocks.push(createInstanceBlock("injected", injected));
 		blocks.push([
@@ -5152,7 +5753,7 @@ function initCustomFormatter() {
 			keywordStyle,
 			v
 		];
-		else if (isObject$1(v)) return ["object", { object: asRaw ? toRaw(v) : v }];
+		else if (isObject$1(v)) return ["object", { object: asRaw ? /* @__PURE__ */ toRaw(v) : v }];
 		else return [
 			"span",
 			stringStyle,
@@ -5173,20 +5774,24 @@ function initCustomFormatter() {
 		if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) return true;
 	}
 	function genRefFlag(v) {
-		if (isShallow(v)) return `ShallowRef`;
+		if (/* @__PURE__ */ isShallow(v)) return `ShallowRef`;
 		if (v.effect) return `ComputedRef`;
 		return `Ref`;
 	}
 	if (window.devtoolsFormatters) window.devtoolsFormatters.push(formatter);
 	else window.devtoolsFormatters = [formatter];
 }
-const version = "3.5.22";
+const version = "3.5.30";
 const warn = !!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
-const devtools = (process.env.NODE_ENV, devtools$1);
-const setDevtoolsHook = (process.env.NODE_ENV, setDevtoolsHook$1);
-
+process.env.NODE_ENV;
+process.env.NODE_ENV;
 //#endregion
-//#region ../../node_modules/.pnpm/@vue+runtime-dom@3.5.22/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
+//#region ../../node_modules/.pnpm/@vue+runtime-dom@3.5.30/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
+/**
+* @vue/runtime-dom v3.5.30
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 let policy = void 0;
 const tt = typeof window !== "undefined" && window.trustedTypes;
 if (tt) try {
@@ -5245,7 +5850,220 @@ const nodeOps = {
 		return [before ? before.nextSibling : parent.firstChild, anchor ? anchor.previousSibling : parent.lastChild];
 	}
 };
-const vtcKey = Symbol("_vtc");
+const TRANSITION = "transition";
+const ANIMATION = "animation";
+const vtcKey = /* @__PURE__ */ Symbol("_vtc");
+const DOMTransitionPropsValidators = {
+	name: String,
+	type: String,
+	css: {
+		type: Boolean,
+		default: true
+	},
+	duration: [
+		String,
+		Number,
+		Object
+	],
+	enterFromClass: String,
+	enterActiveClass: String,
+	enterToClass: String,
+	appearFromClass: String,
+	appearActiveClass: String,
+	appearToClass: String,
+	leaveFromClass: String,
+	leaveActiveClass: String,
+	leaveToClass: String
+};
+const TransitionPropsValidators = /* @__PURE__ */ extend({}, BaseTransitionPropsValidators, DOMTransitionPropsValidators);
+const callHook = (hook, args = []) => {
+	if (isArray(hook)) hook.forEach((h2) => h2(...args));
+	else if (hook) hook(...args);
+};
+const hasExplicitCallback = (hook) => {
+	return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+};
+function resolveTransitionProps(rawProps) {
+	const baseProps = {};
+	for (const key in rawProps) if (!(key in DOMTransitionPropsValidators)) baseProps[key] = rawProps[key];
+	if (rawProps.css === false) return baseProps;
+	const { name = "v", type, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;
+	const durations = normalizeDuration(duration);
+	const enterDuration = durations && durations[0];
+	const leaveDuration = durations && durations[1];
+	const { onBeforeEnter, onEnter, onEnterCancelled, onLeave, onLeaveCancelled, onBeforeAppear = onBeforeEnter, onAppear = onEnter, onAppearCancelled = onEnterCancelled } = baseProps;
+	const finishEnter = (el, isAppear, done, isCancelled) => {
+		el._enterCancelled = isCancelled;
+		removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
+		removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
+		done && done();
+	};
+	const finishLeave = (el, done) => {
+		el._isLeaving = false;
+		removeTransitionClass(el, leaveFromClass);
+		removeTransitionClass(el, leaveToClass);
+		removeTransitionClass(el, leaveActiveClass);
+		done && done();
+	};
+	const makeEnterHook = (isAppear) => {
+		return (el, done) => {
+			const hook = isAppear ? onAppear : onEnter;
+			const resolve = () => finishEnter(el, isAppear, done);
+			callHook(hook, [el, resolve]);
+			nextFrame(() => {
+				removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
+				addTransitionClass(el, isAppear ? appearToClass : enterToClass);
+				if (!hasExplicitCallback(hook)) whenTransitionEnds(el, type, enterDuration, resolve);
+			});
+		};
+	};
+	return extend(baseProps, {
+		onBeforeEnter(el) {
+			callHook(onBeforeEnter, [el]);
+			addTransitionClass(el, enterFromClass);
+			addTransitionClass(el, enterActiveClass);
+		},
+		onBeforeAppear(el) {
+			callHook(onBeforeAppear, [el]);
+			addTransitionClass(el, appearFromClass);
+			addTransitionClass(el, appearActiveClass);
+		},
+		onEnter: makeEnterHook(false),
+		onAppear: makeEnterHook(true),
+		onLeave(el, done) {
+			el._isLeaving = true;
+			const resolve = () => finishLeave(el, done);
+			addTransitionClass(el, leaveFromClass);
+			if (!el._enterCancelled) {
+				forceReflow(el);
+				addTransitionClass(el, leaveActiveClass);
+			} else {
+				addTransitionClass(el, leaveActiveClass);
+				forceReflow(el);
+			}
+			nextFrame(() => {
+				if (!el._isLeaving) return;
+				removeTransitionClass(el, leaveFromClass);
+				addTransitionClass(el, leaveToClass);
+				if (!hasExplicitCallback(onLeave)) whenTransitionEnds(el, type, leaveDuration, resolve);
+			});
+			callHook(onLeave, [el, resolve]);
+		},
+		onEnterCancelled(el) {
+			finishEnter(el, false, void 0, true);
+			callHook(onEnterCancelled, [el]);
+		},
+		onAppearCancelled(el) {
+			finishEnter(el, true, void 0, true);
+			callHook(onAppearCancelled, [el]);
+		},
+		onLeaveCancelled(el) {
+			finishLeave(el);
+			callHook(onLeaveCancelled, [el]);
+		}
+	});
+}
+function normalizeDuration(duration) {
+	if (duration == null) return null;
+	else if (isObject$1(duration)) return [NumberOf(duration.enter), NumberOf(duration.leave)];
+	else {
+		const n = NumberOf(duration);
+		return [n, n];
+	}
+}
+function NumberOf(val) {
+	const res = toNumber(val);
+	if (!!(process.env.NODE_ENV !== "production")) assertNumber(res, "<transition> explicit duration");
+	return res;
+}
+function addTransitionClass(el, cls) {
+	cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
+	(el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
+}
+function removeTransitionClass(el, cls) {
+	cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
+	const _vtc = el[vtcKey];
+	if (_vtc) {
+		_vtc.delete(cls);
+		if (!_vtc.size) el[vtcKey] = void 0;
+	}
+}
+function nextFrame(cb) {
+	requestAnimationFrame(() => {
+		requestAnimationFrame(cb);
+	});
+}
+let endId = 0;
+function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
+	const id = el._endId = ++endId;
+	const resolveIfNotStale = () => {
+		if (id === el._endId) resolve();
+	};
+	if (explicitTimeout != null) return setTimeout(resolveIfNotStale, explicitTimeout);
+	const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+	if (!type) return resolve();
+	const endEvent = type + "end";
+	let ended = 0;
+	const end = () => {
+		el.removeEventListener(endEvent, onEnd);
+		resolveIfNotStale();
+	};
+	const onEnd = (e) => {
+		if (e.target === el && ++ended >= propCount) end();
+	};
+	setTimeout(() => {
+		if (ended < propCount) end();
+	}, timeout + 1);
+	el.addEventListener(endEvent, onEnd);
+}
+function getTransitionInfo(el, expectedType) {
+	const styles = window.getComputedStyle(el);
+	const getStyleProperties = (key) => (styles[key] || "").split(", ");
+	const transitionDelays = getStyleProperties(`${TRANSITION}Delay`);
+	const transitionDurations = getStyleProperties(`${TRANSITION}Duration`);
+	const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+	const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
+	const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
+	const animationTimeout = getTimeout(animationDelays, animationDurations);
+	let type = null;
+	let timeout = 0;
+	let propCount = 0;
+	if (expectedType === TRANSITION) {
+		if (transitionTimeout > 0) {
+			type = TRANSITION;
+			timeout = transitionTimeout;
+			propCount = transitionDurations.length;
+		}
+	} else if (expectedType === ANIMATION) {
+		if (animationTimeout > 0) {
+			type = ANIMATION;
+			timeout = animationTimeout;
+			propCount = animationDurations.length;
+		}
+	} else {
+		timeout = Math.max(transitionTimeout, animationTimeout);
+		type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION : ANIMATION : null;
+		propCount = type ? type === TRANSITION ? transitionDurations.length : animationDurations.length : 0;
+	}
+	const hasTransform = type === TRANSITION && /\b(?:transform|all)(?:,|$)/.test(getStyleProperties(`${TRANSITION}Property`).toString());
+	return {
+		type,
+		timeout,
+		propCount,
+		hasTransform
+	};
+}
+function getTimeout(delays, durations) {
+	while (delays.length < durations.length) delays = delays.concat(delays);
+	return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
+}
+function toMs(s) {
+	if (s === "auto") return 0;
+	return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+}
+function forceReflow(el) {
+	return (el ? el.ownerDocument : document).body.offsetHeight;
+}
 function patchClass(el, value, isSVG) {
 	const transitionClasses = el[vtcKey];
 	if (transitionClasses) value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
@@ -5253,8 +6071,8 @@ function patchClass(el, value, isSVG) {
 	else if (isSVG) el.setAttribute("class", value);
 	else el.className = value;
 }
-const vShowOriginalDisplay = Symbol("_vod");
-const vShowHidden = Symbol("_vsh");
+const vShowOriginalDisplay = /* @__PURE__ */ Symbol("_vod");
+const vShowHidden = /* @__PURE__ */ Symbol("_vsh");
 const vShow = {
 	name: "show",
 	beforeMount(el, { value }, { transition }) {
@@ -5284,7 +6102,7 @@ function setDisplay(el, value) {
 	el.style.display = value ? el[vShowOriginalDisplay] : "none";
 	el[vShowHidden] = !value;
 }
-const CSS_VAR_TEXT = Symbol(!!(process.env.NODE_ENV !== "production") ? "CSS_VAR_TEXT" : "");
+const CSS_VAR_TEXT = /* @__PURE__ */ Symbol(!!(process.env.NODE_ENV !== "production") ? "CSS_VAR_TEXT" : "");
 const displayRE = /(?:^|;)\s*display\s*:/;
 function patchStyle(el, prev, next) {
 	const style = el.style;
@@ -5350,11 +6168,11 @@ function autoPrefix(style, rawName) {
 	return rawName;
 }
 const xlinkNS = "http://www.w3.org/1999/xlink";
-function patchAttr(el, key, value, isSVG, instance, isBoolean$1 = isSpecialBooleanAttr(key)) {
+function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
 	if (isSVG && key.startsWith("xlink:")) if (value == null) el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
 	else el.setAttributeNS(xlinkNS, key, value);
-	else if (value == null || isBoolean$1 && !includeBooleanAttr(value)) el.removeAttribute(key);
-	else el.setAttribute(key, isBoolean$1 ? "" : isSymbol(value) ? String(value) : value);
+	else if (value == null || isBoolean && !includeBooleanAttr(value)) el.removeAttribute(key);
+	else el.setAttribute(key, isBoolean ? "" : isSymbol(value) ? String(value) : value);
 }
 function patchDOMProp(el, key, value, parentComponent, attrName) {
 	if (key === "innerHTML" || key === "textContent") {
@@ -5395,7 +6213,7 @@ function addEventListener(el, event, handler, options) {
 function removeEventListener(el, event, handler, options) {
 	el.removeEventListener(event, handler, options);
 }
-const veiKey = Symbol("_vei");
+const veiKey = /* @__PURE__ */ Symbol("_vei");
 function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
 	const invokers = el[veiKey] || (el[veiKey] = {});
 	const existingInvoker = invokers[rawName];
@@ -5461,7 +6279,7 @@ const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) =>
 	} else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
 		patchDOMProp(el, key, nextValue);
 		if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
-	} else if (el._isVueCE && (/[A-Z]/.test(key) || !isString(nextValue))) patchDOMProp(el, camelize$1(key), nextValue, parentComponent, key);
+	} else if (el._isVueCE && (shouldSetAsPropForVueCE(el, key) || el._def.__asyncLoader && (/[A-Z]/.test(key) || !isString(nextValue)))) patchDOMProp(el, camelize$1(key), nextValue, parentComponent, key);
 	else {
 		if (key === "true-value") el._trueValue = nextValue;
 		else if (key === "false-value") el._falseValue = nextValue;
@@ -5475,6 +6293,7 @@ function shouldSetAsProp(el, key, value, isSVG) {
 		return false;
 	}
 	if (key === "spellcheck" || key === "draggable" || key === "translate" || key === "autocorrect") return false;
+	if (key === "sandbox" && el.tagName === "IFRAME") return false;
 	if (key === "form") return false;
 	if (key === "list" && el.tagName === "INPUT") return false;
 	if (key === "type" && el.tagName === "TEXTAREA") return false;
@@ -5485,10 +6304,16 @@ function shouldSetAsProp(el, key, value, isSVG) {
 	if (isNativeOn(key) && isString(value)) return false;
 	return key in el;
 }
+function shouldSetAsPropForVueCE(el, key) {
+	const props = el._def.props;
+	if (!props) return false;
+	const camelKey = camelize$1(key);
+	return Array.isArray(props) ? props.some((prop) => camelize$1(prop) === camelKey) : Object.keys(props).some((prop) => camelize$1(prop) === camelKey);
+}
 const REMOVAL = {};
 /* @__NO_SIDE_EFFECTS__ */
 function defineCustomElement(options, extraOptions, _createApp) {
-	let Comp = defineComponent(options, extraOptions);
+	let Comp = /* @__PURE__ */ defineComponent(options, extraOptions);
 	if (isPlainObject(Comp)) Comp = extend({}, Comp, extraOptions);
 	class VueCustomElement extends VueElement {
 		constructor(initialProps) {
@@ -5520,8 +6345,11 @@ var VueElement = class VueElement extends BaseClass {
 		this._nonce = this._def.nonce;
 		this._connected = false;
 		this._resolved = false;
+		this._patching = false;
+		this._dirty = false;
 		this._numberProps = null;
 		this._styleChildren = /* @__PURE__ */ new WeakSet();
+		this._styleAnchors = /* @__PURE__ */ new WeakMap();
 		this._ob = null;
 		if (this.shadowRoot && _createApp !== createApp) this._root = this.shadowRoot;
 		else {
@@ -5537,7 +6365,7 @@ var VueElement = class VueElement extends BaseClass {
 		if (!this.shadowRoot && !this._resolved) this._parseSlots();
 		this._connected = true;
 		let parent = this;
-		while (parent = parent && (parent.parentNode || parent.host)) if (parent instanceof VueElement) {
+		while (parent = parent && (parent.assignedSlot || parent.parentNode || parent.host)) if (parent instanceof VueElement) {
 			this._parent = parent;
 			break;
 		}
@@ -5586,10 +6414,10 @@ var VueElement = class VueElement extends BaseClass {
 		for (let i = 0; i < this.attributes.length; i++) this._setAttr(this.attributes[i].name);
 		this._ob = new MutationObserver(this._processMutations.bind(this));
 		this._ob.observe(this, { attributes: true });
-		const resolve = (def$1, isAsync = false) => {
+		const resolve = (def, isAsync = false) => {
 			this._resolved = true;
 			this._pendingResolve = void 0;
-			const { props, styles } = def$1;
+			const { props, styles } = def;
 			let numberProps;
 			if (props && !isArray(props)) for (const key in props) {
 				const opt = props[key];
@@ -5599,32 +6427,32 @@ var VueElement = class VueElement extends BaseClass {
 				}
 			}
 			this._numberProps = numberProps;
-			this._resolveProps(def$1);
+			this._resolveProps(def);
 			if (this.shadowRoot) this._applyStyles(styles);
 			else if (!!(process.env.NODE_ENV !== "production") && styles) warn("Custom element style injection is not supported when using shadowRoot: false");
-			this._mount(def$1);
+			this._mount(def);
 		};
 		const asyncDef = this._def.__asyncLoader;
-		if (asyncDef) this._pendingResolve = asyncDef().then((def$1) => {
-			def$1.configureApp = this._def.configureApp;
-			resolve(this._def = def$1, true);
+		if (asyncDef) this._pendingResolve = asyncDef().then((def) => {
+			def.configureApp = this._def.configureApp;
+			resolve(this._def = def, true);
 		});
 		else resolve(this._def);
 	}
-	_mount(def$1) {
-		if ((!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) && !def$1.name) def$1.name = "VueElement";
-		this._app = this._createApp(def$1);
+	_mount(def) {
+		if ((!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) && !def.name) def.name = "VueElement";
+		this._app = this._createApp(def);
 		this._inheritParentContext();
-		if (def$1.configureApp) def$1.configureApp(this._app);
+		if (def.configureApp) def.configureApp(this._app);
 		this._app._ceVNode = this._createVNode();
 		this._app.mount(this._root);
 		const exposed = this._instance && this._instance.exposed;
 		if (!exposed) return;
-		for (const key in exposed) if (!hasOwn$1(this, key)) Object.defineProperty(this, key, { get: () => unref(exposed[key]) });
+		for (const key in exposed) if (!hasOwn(this, key)) Object.defineProperty(this, key, { get: () => unref(exposed[key]) });
 		else if (!!(process.env.NODE_ENV !== "production")) warn(`Exposed property "${key}" already exists on custom element.`);
 	}
-	_resolveProps(def$1) {
-		const { props } = def$1;
+	_resolveProps(def) {
+		const { props } = def;
 		const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
 		for (const key of Object.keys(this)) if (key[0] !== "_" && declaredPropKeys.includes(key)) this._setProp(key, this[key]);
 		for (const key of declaredPropKeys.map(camelize$1)) Object.defineProperty(this, key, {
@@ -5632,7 +6460,7 @@ var VueElement = class VueElement extends BaseClass {
 				return this._getProp(key);
 			},
 			set(val) {
-				this._setProp(key, val, true, true);
+				this._setProp(key, val, true, !this._patching);
 			}
 		});
 	}
@@ -5655,6 +6483,7 @@ var VueElement = class VueElement extends BaseClass {
 	*/
 	_setProp(key, val, shouldReflect = true, shouldUpdate = false) {
 		if (val !== this._props[key]) {
+			this._dirty = true;
 			if (val === REMOVAL) delete this._props[key];
 			else {
 				this._props[key] = val;
@@ -5692,6 +6521,7 @@ var VueElement = class VueElement extends BaseClass {
 					this._styles.forEach((s) => this._root.removeChild(s));
 					this._styles.length = 0;
 				}
+				this._styleAnchors.delete(this._def);
 				this._applyStyles(newStyles);
 				this._instance = null;
 				this._update();
@@ -5707,18 +6537,26 @@ var VueElement = class VueElement extends BaseClass {
 		};
 		return vnode;
 	}
-	_applyStyles(styles, owner) {
+	_applyStyles(styles, owner, parentComp) {
 		if (!styles) return;
 		if (owner) {
 			if (owner === this._def || this._styleChildren.has(owner)) return;
 			this._styleChildren.add(owner);
 		}
 		const nonce = this._nonce;
+		const root = this.shadowRoot;
+		const insertionAnchor = parentComp ? this._getStyleAnchor(parentComp) || this._getStyleAnchor(this._def) : this._getRootStyleInsertionAnchor(root);
+		let last = null;
 		for (let i = styles.length - 1; i >= 0; i--) {
 			const s = document.createElement("style");
 			if (nonce) s.setAttribute("nonce", nonce);
 			s.textContent = styles[i];
-			this.shadowRoot.prepend(s);
+			root.insertBefore(s, last || insertionAnchor);
+			last = s;
+			if (i === 0) {
+				if (!parentComp) this._styleAnchors.set(this._def, s);
+				if (owner) this._styleAnchors.set(owner, s);
+			}
 			if (!!(process.env.NODE_ENV !== "production")) if (owner) {
 				if (owner.__hmrId) {
 					if (!this._childStyles) this._childStyles = /* @__PURE__ */ new Map();
@@ -5729,6 +6567,20 @@ var VueElement = class VueElement extends BaseClass {
 			} else (this._styles || (this._styles = [])).push(s);
 		}
 	}
+	_getStyleAnchor(comp) {
+		if (!comp) return null;
+		const anchor = this._styleAnchors.get(comp);
+		if (anchor && anchor.parentNode === this.shadowRoot) return anchor;
+		if (anchor) this._styleAnchors.delete(comp);
+		return null;
+	}
+	_getRootStyleInsertionAnchor(root) {
+		for (let i = 0; i < root.childNodes.length; i++) {
+			const node = root.childNodes[i];
+			if (!(node instanceof HTMLStyleElement)) return node;
+		}
+		return null;
+	}
 	/**
 	* Only called when shadowRoot is false
 	*/
@@ -5772,16 +6624,38 @@ var VueElement = class VueElement extends BaseClass {
 	_getSlots() {
 		const roots = [this];
 		if (this._teleportTargets) roots.push(...this._teleportTargets);
-		return roots.reduce((res, i) => {
-			res.push(...Array.from(i.querySelectorAll("slot")));
-			return res;
-		}, []);
+		const slots = /* @__PURE__ */ new Set();
+		for (const root of roots) {
+			const found = root.querySelectorAll("slot");
+			for (let i = 0; i < found.length; i++) slots.add(found[i]);
+		}
+		return Array.from(slots);
+	}
+	/**
+	* @internal
+	*/
+	_injectChildStyle(comp, parentComp) {
+		this._applyStyles(comp.styles, comp, parentComp);
+	}
+	/**
+	* @internal
+	*/
+	_beginPatch() {
+		this._patching = true;
+		this._dirty = false;
+	}
+	/**
+	* @internal
+	*/
+	_endPatch() {
+		this._patching = false;
+		if (this._dirty && this._instance) this._update();
 	}
 	/**
 	* @internal
 	*/
-	_injectChildStyle(comp) {
-		this._applyStyles(comp.styles, comp);
+	_hasShadowRoot() {
+		return this._def.shadowRoot !== false;
 	}
 	/**
 	* @internal
@@ -5789,6 +6663,7 @@ var VueElement = class VueElement extends BaseClass {
 	_removeChildStyle(comp) {
 		if (!!(process.env.NODE_ENV !== "production")) {
 			this._styleChildren.delete(comp);
+			this._styleAnchors.delete(comp);
 			if (this._childStyles && comp.__hmrId) {
 				const oldStyles = this._childStyles.get(comp.__hmrId);
 				if (oldStyles) {
@@ -5799,9 +6674,180 @@ var VueElement = class VueElement extends BaseClass {
 		}
 	}
 };
-const moveCbKey = Symbol("_moveCb");
-const enterCbKey = Symbol("_enterCb");
-const assignKey = Symbol("_assign");
+const positionMap = /* @__PURE__ */ new WeakMap();
+const newPositionMap = /* @__PURE__ */ new WeakMap();
+const moveCbKey = /* @__PURE__ */ Symbol("_moveCb");
+const enterCbKey = /* @__PURE__ */ Symbol("_enterCb");
+const decorate = (t) => {
+	delete t.props.mode;
+	return t;
+};
+const TransitionGroup = /* @__PURE__ */ decorate({
+	name: "TransitionGroup",
+	props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
+		tag: String,
+		moveClass: String
+	}),
+	setup(props, { slots }) {
+		const instance = getCurrentInstance();
+		const state = useTransitionState();
+		let prevChildren;
+		let children;
+		onUpdated(() => {
+			if (!prevChildren.length) return;
+			const moveClass = props.moveClass || `${props.name || "v"}-move`;
+			if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) {
+				prevChildren = [];
+				return;
+			}
+			prevChildren.forEach(callPendingCbs);
+			prevChildren.forEach(recordPosition);
+			const movedChildren = prevChildren.filter(applyTranslation);
+			forceReflow(instance.vnode.el);
+			movedChildren.forEach((c) => {
+				const el = c.el;
+				const style = el.style;
+				addTransitionClass(el, moveClass);
+				style.transform = style.webkitTransform = style.transitionDuration = "";
+				const cb = el[moveCbKey] = (e) => {
+					if (e && e.target !== el) return;
+					if (!e || e.propertyName.endsWith("transform")) {
+						el.removeEventListener("transitionend", cb);
+						el[moveCbKey] = null;
+						removeTransitionClass(el, moveClass);
+					}
+				};
+				el.addEventListener("transitionend", cb);
+			});
+			prevChildren = [];
+		});
+		return () => {
+			const rawProps = /* @__PURE__ */ toRaw(props);
+			const cssTransitionProps = resolveTransitionProps(rawProps);
+			let tag = rawProps.tag || Fragment;
+			prevChildren = [];
+			if (children) for (let i = 0; i < children.length; i++) {
+				const child = children[i];
+				if (child.el && child.el instanceof Element) {
+					prevChildren.push(child);
+					setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));
+					positionMap.set(child, getPosition(child.el));
+				}
+			}
+			children = slots.default ? getTransitionRawChildren(slots.default()) : [];
+			for (let i = 0; i < children.length; i++) {
+				const child = children[i];
+				if (child.key != null) setTransitionHooks(child, resolveTransitionHooks(child, cssTransitionProps, state, instance));
+				else if (!!(process.env.NODE_ENV !== "production") && child.type !== Text) warn(`<TransitionGroup> children must be keyed.`);
+			}
+			return createVNode(tag, null, children);
+		};
+	}
+});
+function callPendingCbs(c) {
+	const el = c.el;
+	if (el[moveCbKey]) el[moveCbKey]();
+	if (el[enterCbKey]) el[enterCbKey]();
+}
+function recordPosition(c) {
+	newPositionMap.set(c, getPosition(c.el));
+}
+function applyTranslation(c) {
+	const oldPos = positionMap.get(c);
+	const newPos = newPositionMap.get(c);
+	const dx = oldPos.left - newPos.left;
+	const dy = oldPos.top - newPos.top;
+	if (dx || dy) {
+		const el = c.el;
+		const s = el.style;
+		const rect = el.getBoundingClientRect();
+		let scaleX = 1;
+		let scaleY = 1;
+		if (el.offsetWidth) scaleX = rect.width / el.offsetWidth;
+		if (el.offsetHeight) scaleY = rect.height / el.offsetHeight;
+		if (!Number.isFinite(scaleX) || scaleX === 0) scaleX = 1;
+		if (!Number.isFinite(scaleY) || scaleY === 0) scaleY = 1;
+		if (Math.abs(scaleX - 1) < .01) scaleX = 1;
+		if (Math.abs(scaleY - 1) < .01) scaleY = 1;
+		s.transform = s.webkitTransform = `translate(${dx / scaleX}px,${dy / scaleY}px)`;
+		s.transitionDuration = "0s";
+		return c;
+	}
+}
+function getPosition(el) {
+	const rect = el.getBoundingClientRect();
+	return {
+		left: rect.left,
+		top: rect.top
+	};
+}
+function hasCSSTransform(el, root, moveClass) {
+	const clone = el.cloneNode();
+	const _vtc = el[vtcKey];
+	if (_vtc) _vtc.forEach((cls) => {
+		cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
+	});
+	moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
+	clone.style.display = "none";
+	const container = root.nodeType === 1 ? root : root.parentNode;
+	container.appendChild(clone);
+	const { hasTransform } = getTransitionInfo(clone);
+	container.removeChild(clone);
+	return hasTransform;
+}
+const getModelAssigner = (vnode) => {
+	const fn = vnode.props["onUpdate:modelValue"] || false;
+	return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
+};
+function onCompositionStart(e) {
+	e.target.composing = true;
+}
+function onCompositionEnd(e) {
+	const target = e.target;
+	if (target.composing) {
+		target.composing = false;
+		target.dispatchEvent(new Event("input"));
+	}
+}
+const assignKey = /* @__PURE__ */ Symbol("_assign");
+function castValue(value, trim, number) {
+	if (trim) value = value.trim();
+	if (number) value = looseToNumber(value);
+	return value;
+}
+const vModelText = {
+	created(el, { modifiers: { lazy, trim, number } }, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		const castToNumber = number || vnode.props && vnode.props.type === "number";
+		addEventListener(el, lazy ? "change" : "input", (e) => {
+			if (e.target.composing) return;
+			el[assignKey](castValue(el.value, trim, castToNumber));
+		});
+		if (trim || castToNumber) addEventListener(el, "change", () => {
+			el.value = castValue(el.value, trim, castToNumber);
+		});
+		if (!lazy) {
+			addEventListener(el, "compositionstart", onCompositionStart);
+			addEventListener(el, "compositionend", onCompositionEnd);
+			addEventListener(el, "change", onCompositionEnd);
+		}
+	},
+	mounted(el, { value }) {
+		el.value = value == null ? "" : value;
+	},
+	beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
+		el[assignKey] = getModelAssigner(vnode);
+		if (el.composing) return;
+		const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
+		const newValue = value == null ? "" : value;
+		if (elValue === newValue) return;
+		if (document.activeElement === el && el.type !== "range") {
+			if (lazy && value === oldValue) return;
+			if (trim && el.value.trim() === newValue) return;
+		}
+		el.value = newValue;
+	}
+};
 const systemModifiers = [
 	"ctrl",
 	"shift",
@@ -5822,6 +6868,7 @@ const modifierGuards = {
 	exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
 };
 const withModifiers = (fn, modifiers) => {
+	if (!fn) return fn;
 	const cache = fn._withMods || (fn._withMods = {});
 	const cacheKey = modifiers.join(".");
 	return cache[cacheKey] || (cache[cacheKey] = ((event, ...args) => {
@@ -5832,6 +6879,24 @@ const withModifiers = (fn, modifiers) => {
 		return fn(event, ...args);
 	}));
 };
+const keyNames = {
+	esc: "escape",
+	space: " ",
+	up: "arrow-up",
+	left: "arrow-left",
+	right: "arrow-right",
+	down: "arrow-down",
+	delete: "backspace"
+};
+const withKeys = (fn, modifiers) => {
+	const cache = fn._withKeys || (fn._withKeys = {});
+	const cacheKey = modifiers.join(".");
+	return cache[cacheKey] || (cache[cacheKey] = ((event) => {
+		if (!("key" in event)) return;
+		const eventKey = hyphenate$1(event.key);
+		if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) return fn(event);
+	}));
+};
 const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
 let renderer;
 function ensureRenderer() {
@@ -5908,16 +6973,19 @@ function normalizeContainer(container) {
 	if (!!(process.env.NODE_ENV !== "production") && window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") warn(`mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`);
 	return container;
 }
-
 //#endregion
-//#region ../../node_modules/.pnpm/vue@3.5.22_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+//#region ../../node_modules/.pnpm/vue@3.5.30_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+/**
+* vue v3.5.30
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 function initDev() {
 	initCustomFormatter();
 }
 if (!!(process.env.NODE_ENV !== "production")) initDev();
-
 //#endregion
-//#region ../../node_modules/.pnpm/@vueuse+shared@14.0.0_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
+//#region ../../node_modules/.pnpm/@vueuse+shared@14.2.1_vue@3.5.30_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
 /**
 * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
 *
@@ -5952,18 +7020,23 @@ const injectLocal = (...args) => {
 	return inject(...args);
 };
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
-const isWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
 const notNullish = (val) => val != null;
 const toString = Object.prototype.toString;
 const isObject = (val) => toString.call(val) === "[object Object]";
 const noop = () => {};
+const isIOS = /* @__PURE__ */ getIsIOS();
+function getIsIOS() {
+	var _window, _window2, _window3;
+	return isClient && !!((_window = window) === null || _window === void 0 || (_window = _window.navigator) === null || _window === void 0 ? void 0 : _window.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_window2 = window) === null || _window2 === void 0 || (_window2 = _window2.navigator) === null || _window2 === void 0 ? void 0 : _window2.maxTouchPoints) > 2 && /iPad|Macintosh/.test((_window3 = window) === null || _window3 === void 0 ? void 0 : _window3.navigator.userAgent));
+}
 function toRef(...args) {
-	if (args.length !== 1) return toRef$1(...args);
+	if (args.length !== 1) return /* @__PURE__ */ toRef$1(...args);
 	const r = args[0];
-	return typeof r === "function" ? readonly(customRef(() => ({
+	return typeof r === "function" ? /* @__PURE__ */ readonly(customRef(() => ({
 		get: r,
 		set: noop
-	}))) : ref(r);
+	}))) : /* @__PURE__ */ ref(r);
 }
 /**
 * @internal
@@ -6043,7 +7116,7 @@ function pausableFilter(extendFilter = bypassFilter, options = {}) {
 		if (isActive.value) extendFilter(...args);
 	};
 	return {
-		isActive: readonly(isActive),
+		isActive: /* @__PURE__ */ readonly(isActive),
 		pause,
 		resume,
 		eventFilter
@@ -6065,9 +7138,9 @@ function cacheStringFunction(fn) {
 	});
 }
 const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
 const camelizeRE = /-(\w)/g;
-const camelize = cacheStringFunction((str) => {
+cacheStringFunction((str) => {
 	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
 });
 function getLifeCycleTarget(target) {
@@ -6089,11 +7162,12 @@ function useDebounceFn(fn, ms = 200, options = {}) {
 	return createFilterWrapper(debounceFilter(ms, options), fn);
 }
 function watchWithFilter(source, cb, options = {}) {
-	const { eventFilter = bypassFilter,...watchOptions } = options;
+	const { eventFilter = bypassFilter, ...watchOptions } = options;
 	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
 }
+/** @deprecated Use Vue's built-in `watch` instead. This function will be removed in future version. */
 function watchPausable(source, cb, options = {}) {
-	const { eventFilter: filter, initialState = "active",...watchOptions } = options;
+	const { eventFilter: filter, initialState = "active", ...watchOptions } = options;
 	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
 	return {
 		stop: watchWithFilter(source, cb, {
@@ -6105,41 +7179,6 @@ function watchPausable(source, cb, options = {}) {
 		isActive
 	};
 }
-/** @deprecated use `watchPausable` instead */
-const pausableWatch = watchPausable;
-/**
-* Extended `toRefs` that also accepts refs of an object.
-*
-* @see https://vueuse.org/toRefs
-* @param objectRef A ref or normal object or array.
-* @param options Options
-*/
-function toRefs(objectRef, options = {}) {
-	if (!isRef(objectRef)) return toRefs$1(objectRef);
-	const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};
-	for (const key in objectRef.value) result[key] = customRef(() => ({
-		get() {
-			return objectRef.value[key];
-		},
-		set(v) {
-			var _toValue;
-			if ((_toValue = toValue(options.replaceRef)) !== null && _toValue !== void 0 ? _toValue : true) if (Array.isArray(objectRef.value)) {
-				const copy = [...objectRef.value];
-				copy[key] = v;
-				objectRef.value = copy;
-			} else {
-				const newObject = {
-					...objectRef.value,
-					[key]: v
-				};
-				Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));
-				objectRef.value = newObject;
-			}
-			else objectRef.value[key] = v;
-		}
-	}));
-	return result;
-}
 /**
 * Call onMounted() if it's inside a component lifecycle, if not, just call the function
 *
@@ -6153,6 +7192,54 @@ function tryOnMounted(fn, sync = true, target) {
 	else nextTick(fn);
 }
 /**
+* Wrapper for `setInterval` with controls
+*
+* @see https://vueuse.org/useIntervalFn
+* @param cb
+* @param interval
+* @param options
+*/
+function useIntervalFn(cb, interval = 1e3, options = {}) {
+	const { immediate = true, immediateCallback = false } = options;
+	let timer = null;
+	const isActive = /* @__PURE__ */ shallowRef(false);
+	function clean() {
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+	}
+	function pause() {
+		isActive.value = false;
+		clean();
+	}
+	function resume() {
+		const intervalValue = toValue(interval);
+		if (intervalValue <= 0) return;
+		isActive.value = true;
+		if (immediateCallback) cb();
+		clean();
+		if (isActive.value) timer = setInterval(cb, intervalValue);
+	}
+	if (immediate && isClient) resume();
+	if (/* @__PURE__ */ isRef(interval) || typeof interval === "function") tryOnScopeDispose(watch(interval, () => {
+		if (isActive.value && isClient) resume();
+	}));
+	tryOnScopeDispose(pause);
+	return {
+		isActive: /* @__PURE__ */ shallowReadonly(isActive),
+		pause,
+		resume
+	};
+}
+function watchDebounced(source, cb, options = {}) {
+	const { debounce = 0, maxWait = void 0, ...watchOptions } = options;
+	return watchWithFilter(source, cb, {
+		...watchOptions,
+		eventFilter: debounceFilter(debounce, { maxWait })
+	});
+}
+/**
 * Shorthand for watching value with {immediate: true}
 *
 * @see https://vueuse.org/watchImmediate
@@ -6163,13 +7250,12 @@ function watchImmediate(source, cb, options) {
 		immediate: true
 	});
 }
-
 //#endregion
-//#region ../../node_modules/.pnpm/@vueuse+core@14.0.0_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js
+//#region ../../node_modules/.pnpm/@vueuse+core@14.2.1_vue@3.5.30_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js
 const defaultWindow = isClient ? window : void 0;
-const defaultDocument = isClient ? window.document : void 0;
-const defaultNavigator = isClient ? window.navigator : void 0;
-const defaultLocation = isClient ? window.location : void 0;
+isClient && window.document;
+isClient && window.navigator;
+isClient && window.location;
 /**
 * Get the dom element of a ref of element or Vue component instance
 *
@@ -6181,11 +7267,6 @@ function unrefElement(elRef) {
 	return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
 }
 function useEventListener(...args) {
-	const cleanups = [];
-	const cleanup = () => {
-		cleanups.forEach((fn) => fn());
-		cleanups.length = 0;
-	};
 	const register = (el, event, listener, options) => {
 		el.addEventListener(event, listener, options);
 		return () => el.removeEventListener(event, listener, options);
@@ -6194,7 +7275,7 @@ function useEventListener(...args) {
 		const test = toArray(toValue(args[0])).filter((e) => e != null);
 		return test.every((e) => typeof e !== "string") ? test : void 0;
 	});
-	const stopWatch = watchImmediate(() => {
+	return watchImmediate(() => {
 		var _firstParamTargets$va, _firstParamTargets$va2;
 		return [
 			(_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
@@ -6202,18 +7283,104 @@ function useEventListener(...args) {
 			toArray(unref(firstParamTargets.value ? args[2] : args[1])),
 			toValue(firstParamTargets.value ? args[3] : args[2])
 		];
-	}, ([raw_targets, raw_events, raw_listeners, raw_options]) => {
-		cleanup();
+	}, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
 		if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
 		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
-		cleanups.push(...raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone)))));
+		const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+		onCleanup(() => {
+			cleanups.forEach((fn) => fn());
+		});
 	}, { flush: "post" });
-	const stop$1 = () => {
-		stopWatch();
-		cleanup();
+}
+let _iOSWorkaround = false;
+function onClickOutside(target, handler, options = {}) {
+	const { window: window$1 = defaultWindow, ignore = [], capture = true, detectIframe = false, controls = false } = options;
+	if (!window$1) return controls ? {
+		stop: noop,
+		cancel: noop,
+		trigger: noop
+	} : noop;
+	if (isIOS && !_iOSWorkaround) {
+		_iOSWorkaround = true;
+		const listenerOptions = { passive: true };
+		Array.from(window$1.document.body.children).forEach((el) => el.addEventListener("click", noop, listenerOptions));
+		window$1.document.documentElement.addEventListener("click", noop, listenerOptions);
+	}
+	let shouldListen = true;
+	const shouldIgnore = (event) => {
+		return toValue(ignore).some((target$1) => {
+			if (typeof target$1 === "string") return Array.from(window$1.document.querySelectorAll(target$1)).some((el) => el === event.target || event.composedPath().includes(el));
+			else {
+				const el = unrefElement(target$1);
+				return el && (event.target === el || event.composedPath().includes(el));
+			}
+		});
+	};
+	/**
+	* Determines if the given target has multiple root elements.
+	* Referenced from: https://github.com/vuejs/test-utils/blob/ccb460be55f9f6be05ab708500a41ec8adf6f4bc/src/vue-wrapper.ts#L21
+	*/
+	function hasMultipleRoots(target$1) {
+		const vm = toValue(target$1);
+		return vm && vm.$.subTree.shapeFlag === 16;
+	}
+	function checkMultipleRoots(target$1, event) {
+		const vm = toValue(target$1);
+		const children = vm.$.subTree && vm.$.subTree.children;
+		if (children == null || !Array.isArray(children)) return false;
+		return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
+	}
+	const listener = (event) => {
+		const el = unrefElement(target);
+		if (event.target == null) return;
+		if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) return;
+		if (!el || el === event.target || event.composedPath().includes(el)) return;
+		if ("detail" in event && event.detail === 0) shouldListen = !shouldIgnore(event);
+		if (!shouldListen) {
+			shouldListen = true;
+			return;
+		}
+		handler(event);
+	};
+	let isProcessingClick = false;
+	const cleanup = [
+		useEventListener(window$1, "click", (event) => {
+			if (!isProcessingClick) {
+				isProcessingClick = true;
+				setTimeout(() => {
+					isProcessingClick = false;
+				}, 0);
+				listener(event);
+			}
+		}, {
+			passive: true,
+			capture
+		}),
+		useEventListener(window$1, "pointerdown", (e) => {
+			const el = unrefElement(target);
+			shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
+		}, { passive: true }),
+		detectIframe && useEventListener(window$1, "blur", (event) => {
+			setTimeout(() => {
+				var _window$document$acti;
+				const el = unrefElement(target);
+				if (((_window$document$acti = window$1.document.activeElement) === null || _window$document$acti === void 0 ? void 0 : _window$document$acti.tagName) === "IFRAME" && !(el === null || el === void 0 ? void 0 : el.contains(window$1.document.activeElement))) handler(event);
+			}, 0);
+		}, { passive: true })
+	].filter(Boolean);
+	const stop = () => cleanup.forEach((fn) => fn());
+	if (controls) return {
+		stop,
+		cancel: () => {
+			shouldListen = false;
+		},
+		trigger: (event) => {
+			shouldListen = true;
+			listener(event);
+			shouldListen = false;
+		}
 	};
-	tryOnScopeDispose(cleanup);
-	return stop$1;
+	return stop;
 }
 /**
 * Mounted state in ref.
@@ -6223,7 +7390,7 @@ function useEventListener(...args) {
 * @__NO_SIDE_EFFECTS__
 */
 function useMounted() {
-	const isMounted = shallowRef(false);
+	const isMounted = /* @__PURE__ */ shallowRef(false);
 	const instance = getCurrentInstance();
 	if (instance) onMounted(() => {
 		isMounted.value = true;
@@ -6248,9 +7415,9 @@ function useSupported(callback) {
 * @param options
 */
 function useMutationObserver(target, callback, options = {}) {
-	const { window: window$1 = defaultWindow,...mutationOptions } = options;
+	const { window: window$1 = defaultWindow, ...mutationOptions } = options;
 	let observer;
-	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "MutationObserver" in window$1);
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "MutationObserver" in window$1);
 	const cleanup = () => {
 		if (observer) {
 			observer.disconnect();
@@ -6262,7 +7429,7 @@ function useMutationObserver(target, callback, options = {}) {
 		return new Set(items);
 	}), (newTargets) => {
 		cleanup();
-		if (isSupported$1.value && newTargets.size) {
+		if (isSupported.value && newTargets.size) {
 			observer = new MutationObserver(callback);
 			newTargets.forEach((el) => observer.observe(el, mutationOptions));
 		}
@@ -6273,17 +7440,75 @@ function useMutationObserver(target, callback, options = {}) {
 	const takeRecords = () => {
 		return observer === null || observer === void 0 ? void 0 : observer.takeRecords();
 	};
-	const stop$1 = () => {
+	const stop = () => {
 		stopWatch();
 		cleanup();
 	};
-	tryOnScopeDispose(stop$1);
+	tryOnScopeDispose(stop);
 	return {
-		isSupported: isSupported$1,
-		stop: stop$1,
+		isSupported,
+		stop,
 		takeRecords
 	};
 }
+/**
+* Call function on every `requestAnimationFrame`. With controls of pausing and resuming.
+*
+* @see https://vueuse.org/useRafFn
+* @param fn
+* @param options
+*/
+function useRafFn(fn, options = {}) {
+	const { immediate = true, fpsLimit = null, window: window$1 = defaultWindow, once = false } = options;
+	const isActive = /* @__PURE__ */ shallowRef(false);
+	const intervalLimit = computed(() => {
+		const limit = toValue(fpsLimit);
+		return limit ? 1e3 / limit : null;
+	});
+	let previousFrameTimestamp = 0;
+	let rafId = null;
+	function loop(timestamp$1) {
+		if (!isActive.value || !window$1) return;
+		if (!previousFrameTimestamp) previousFrameTimestamp = timestamp$1;
+		const delta = timestamp$1 - previousFrameTimestamp;
+		if (intervalLimit.value && delta < intervalLimit.value) {
+			rafId = window$1.requestAnimationFrame(loop);
+			return;
+		}
+		previousFrameTimestamp = timestamp$1;
+		fn({
+			delta,
+			timestamp: timestamp$1
+		});
+		if (once) {
+			isActive.value = false;
+			rafId = null;
+			return;
+		}
+		rafId = window$1.requestAnimationFrame(loop);
+	}
+	function resume() {
+		if (!isActive.value && window$1) {
+			isActive.value = true;
+			previousFrameTimestamp = 0;
+			rafId = window$1.requestAnimationFrame(loop);
+		}
+	}
+	function pause() {
+		isActive.value = false;
+		if (rafId != null && window$1) {
+			window$1.cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+	}
+	if (immediate) resume();
+	tryOnScopeDispose(pause);
+	return {
+		isActive: /* @__PURE__ */ readonly(isActive),
+		pause,
+		resume
+	};
+}
 const ssrWidthSymbol = Symbol("vueuse-ssr-width");
 /* @__NO_SIDE_EFFECTS__ */
 function useSSRWidth() {
@@ -6299,16 +7524,16 @@ function useSSRWidth() {
 */
 function useMediaQuery(query, options = {}) {
 	const { window: window$1 = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
-	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "matchMedia" in window$1 && typeof window$1.matchMedia === "function");
-	const ssrSupport = shallowRef(typeof ssrWidth === "number");
-	const mediaQuery = shallowRef();
-	const matches = shallowRef(false);
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "matchMedia" in window$1 && typeof window$1.matchMedia === "function");
+	const ssrSupport = /* @__PURE__ */ shallowRef(typeof ssrWidth === "number");
+	const mediaQuery = /* @__PURE__ */ shallowRef();
+	const matches = /* @__PURE__ */ shallowRef(false);
 	const handler = (event) => {
 		matches.value = event.matches;
 	};
 	watchEffect(() => {
 		if (ssrSupport.value) {
-			ssrSupport.value = !isSupported$1.value;
+			ssrSupport.value = !isSupported.value;
 			matches.value = toValue(query).split(",").some((queryString) => {
 				const not = queryString.includes("not all");
 				const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
@@ -6320,7 +7545,7 @@ function useMediaQuery(query, options = {}) {
 			});
 			return;
 		}
-		if (!isSupported$1.value) return;
+		if (!isSupported.value) return;
 		mediaQuery.value = window$1.matchMedia(toValue(query));
 		matches.value = mediaQuery.value.matches;
 	});
@@ -6396,7 +7621,7 @@ function useStorage(key, defaults$1, storage, options = {}) {
 	const rawInit = toValue(defaults$1);
 	const type = guessSerializerType(rawInit);
 	const serializer = (_options$serializer = options.serializer) !== null && _options$serializer !== void 0 ? _options$serializer : StorageSerializers[type];
-	const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(data, (newValue) => write(newValue), {
+	const { pause: pauseWatch, resume: resumeWatch } = watchPausable(data, (newValue) => write(newValue), {
 		flush,
 		deep,
 		eventFilter
@@ -6501,7 +7726,7 @@ function useStorage(key, defaults$1, storage, options = {}) {
 */
 function useCssVar(prop, target, options = {}) {
 	const { window: window$1 = defaultWindow, initialValue, observe = false } = options;
-	const variable = shallowRef(initialValue);
+	const variable = /* @__PURE__ */ shallowRef(initialValue);
 	const elRef = computed(() => {
 		var _window$document;
 		return unrefElement(target) || (window$1 === null || window$1 === void 0 || (_window$document = window$1.document) === null || _window$document === void 0 ? void 0 : _window$document.documentElement);
@@ -6538,9 +7763,9 @@ function useCssVar(prop, target, options = {}) {
 * @param options
 */
 function useResizeObserver(target, callback, options = {}) {
-	const { window: window$1 = defaultWindow,...observerOptions } = options;
+	const { window: window$1 = defaultWindow, ...observerOptions } = options;
 	let observer;
-	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "ResizeObserver" in window$1);
+	const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "ResizeObserver" in window$1);
 	const cleanup = () => {
 		if (observer) {
 			observer.disconnect();
@@ -6552,7 +7777,7 @@ function useResizeObserver(target, callback, options = {}) {
 		return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
 	}), (els) => {
 		cleanup();
-		if (isSupported$1.value && window$1) {
+		if (isSupported.value && window$1) {
 			observer = new ResizeObserver(callback);
 			for (const _el of els) if (_el) observer.observe(_el, observerOptions);
 		}
@@ -6560,14 +7785,14 @@ function useResizeObserver(target, callback, options = {}) {
 		immediate: true,
 		flush: "post"
 	});
-	const stop$1 = () => {
+	const stop = () => {
 		cleanup();
 		stopWatch();
 	};
-	tryOnScopeDispose(stop$1);
+	tryOnScopeDispose(stop);
 	return {
-		isSupported: isSupported$1,
-		stop: stop$1
+		isSupported,
+		stop
 	};
 }
 /**
@@ -6578,14 +7803,14 @@ function useResizeObserver(target, callback, options = {}) {
 */
 function useElementBounding(target, options = {}) {
 	const { reset = true, windowResize = true, windowScroll = true, immediate = true, updateTiming = "sync" } = options;
-	const height = shallowRef(0);
-	const bottom = shallowRef(0);
-	const left = shallowRef(0);
-	const right = shallowRef(0);
-	const top = shallowRef(0);
-	const width = shallowRef(0);
-	const x = shallowRef(0);
-	const y = shallowRef(0);
+	const height = /* @__PURE__ */ shallowRef(0);
+	const bottom = /* @__PURE__ */ shallowRef(0);
+	const left = /* @__PURE__ */ shallowRef(0);
+	const right = /* @__PURE__ */ shallowRef(0);
+	const top = /* @__PURE__ */ shallowRef(0);
+	const width = /* @__PURE__ */ shallowRef(0);
+	const x = /* @__PURE__ */ shallowRef(0);
+	const y = /* @__PURE__ */ shallowRef(0);
 	function recalculate() {
 		const el = unrefElement(target);
 		if (!el) {
@@ -6650,6 +7875,32 @@ function useLocalStorage(key, initialValue, options = {}) {
 	const { window: window$1 = defaultWindow } = options;
 	return useStorage(key, initialValue, window$1 === null || window$1 === void 0 ? void 0 : window$1.localStorage, options);
 }
+function getDefaultScheduler$5(options) {
+	if ("interval" in options || "immediate" in options) {
+		const { interval = "requestAnimationFrame", immediate = true } = options;
+		return interval === "requestAnimationFrame" ? (fn) => useRafFn(fn, { immediate }) : (fn) => useIntervalFn(fn, interval, options);
+	}
+	return useRafFn;
+}
+/**
+* Reactive current Date instance.
+*
+* @see https://vueuse.org/useNow
+* @param options
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useNow(options = {}) {
+	const { controls: exposeControls = false, scheduler = getDefaultScheduler$5(options) } = options;
+	const now = /* @__PURE__ */ ref(/* @__PURE__ */ new Date());
+	const update = () => now.value = /* @__PURE__ */ new Date();
+	const controls = scheduler(update);
+	if (exposeControls) return {
+		now,
+		...controls
+	};
+	else return now;
+}
 const topVarName = "--vueuse-safe-area-top";
 const rightVarName = "--vueuse-safe-area-right";
 const bottomVarName = "--vueuse-safe-area-bottom";
@@ -6660,10 +7911,10 @@ const leftVarName = "--vueuse-safe-area-left";
 * @see https://vueuse.org/useScreenSafeArea
 */
 function useScreenSafeArea() {
-	const top = shallowRef("");
-	const right = shallowRef("");
-	const bottom = shallowRef("");
-	const left = shallowRef("");
+	const top = /* @__PURE__ */ shallowRef("");
+	const right = /* @__PURE__ */ shallowRef("");
+	const bottom = /* @__PURE__ */ shallowRef("");
+	const left = /* @__PURE__ */ shallowRef("");
 	if (isClient) {
 		const topCssVar = useCssVar(topVarName);
 		const rightCssVar = useCssVar(rightVarName);
@@ -6730,6 +7981,81 @@ const DEFAULT_UNITS = [
 		name: "year"
 	}
 ];
+const DEFAULT_MESSAGES = {
+	justNow: "just now",
+	past: (n) => n.match(/\d/) ? `${n} ago` : n,
+	future: (n) => n.match(/\d/) ? `in ${n}` : n,
+	month: (n, past) => n === 1 ? past ? "last month" : "next month" : `${n} month${n > 1 ? "s" : ""}`,
+	year: (n, past) => n === 1 ? past ? "last year" : "next year" : `${n} year${n > 1 ? "s" : ""}`,
+	day: (n, past) => n === 1 ? past ? "yesterday" : "tomorrow" : `${n} day${n > 1 ? "s" : ""}`,
+	week: (n, past) => n === 1 ? past ? "last week" : "next week" : `${n} week${n > 1 ? "s" : ""}`,
+	hour: (n) => `${n} hour${n > 1 ? "s" : ""}`,
+	minute: (n) => `${n} minute${n > 1 ? "s" : ""}`,
+	second: (n) => `${n} second${n > 1 ? "s" : ""}`,
+	invalid: ""
+};
+function DEFAULT_FORMATTER(date) {
+	return date.toISOString().slice(0, 10);
+}
+function getDefaultScheduler$4(options) {
+	if ("updateInterval" in options) {
+		const { updateInterval = 3e4 } = options;
+		return (cb) => useIntervalFn(cb, updateInterval);
+	}
+	return (cb) => useIntervalFn(cb, 3e4);
+}
+/**
+* Reactive time ago formatter.
+*
+* @see https://vueuse.org/useTimeAgo
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function useTimeAgo(time, options = {}) {
+	const { controls: exposeControls = false, scheduler = getDefaultScheduler$4(options) } = options;
+	const { now, ...controls } = useNow({
+		scheduler,
+		controls: true
+	});
+	const timeAgo = computed(() => formatTimeAgo(new Date(toValue(time)), options, toValue(now)));
+	if (exposeControls) return {
+		timeAgo,
+		...controls
+	};
+	else return timeAgo;
+}
+function formatTimeAgo(from, options = {}, now = Date.now()) {
+	const { max, messages = DEFAULT_MESSAGES, fullDateFormatter = DEFAULT_FORMATTER, units = DEFAULT_UNITS, showSecond = false, rounding = "round" } = options;
+	const roundFn = typeof rounding === "number" ? (n) => +n.toFixed(rounding) : Math[rounding];
+	const diff = +now - +from;
+	const absDiff = Math.abs(diff);
+	function getValue$1(diff$1, unit) {
+		return roundFn(Math.abs(diff$1) / unit.value);
+	}
+	function format(diff$1, unit) {
+		const val = getValue$1(diff$1, unit);
+		const past = diff$1 > 0;
+		const str = applyFormat(unit.name, val, past);
+		return applyFormat(past ? "past" : "future", str, past);
+	}
+	function applyFormat(name, val, isPast) {
+		const formatter = messages[name];
+		if (typeof formatter === "function") return formatter(val, isPast);
+		return formatter.replace("{0}", val.toString());
+	}
+	if (absDiff < 6e4 && !showSecond) return messages.justNow;
+	if (typeof max === "number" && absDiff > max) return fullDateFormatter(new Date(from));
+	if (typeof max === "string") {
+		var _units$find;
+		const unitMax = (_units$find = units.find((i) => i.name === max)) === null || _units$find === void 0 ? void 0 : _units$find.max;
+		if (unitMax && absDiff > unitMax) return fullDateFormatter(new Date(from));
+	}
+	for (const [idx, unit] of units.entries()) {
+		if (getValue$1(diff, unit) <= 0 && units[idx - 1]) return format(diff, units[idx - 1]);
+		if (absDiff < unit.max) return format(diff, unit);
+	}
+	return messages.invalid;
+}
 /**
 * Reactive window size.
 *
@@ -6740,8 +8066,8 @@ const DEFAULT_UNITS = [
 */
 function useWindowSize(options = {}) {
 	const { window: window$1 = defaultWindow, initialWidth = Number.POSITIVE_INFINITY, initialHeight = Number.POSITIVE_INFINITY, listenOrientation = true, includeScrollbar = true, type = "inner" } = options;
-	const width = shallowRef(initialWidth);
-	const height = shallowRef(initialHeight);
+	const width = /* @__PURE__ */ shallowRef(initialWidth);
+	const height = /* @__PURE__ */ shallowRef(initialHeight);
 	const update = () => {
 		if (window$1) if (type === "outer") {
 			width.value = window$1.outerWidth;
@@ -6769,6 +8095,5 @@ function useWindowSize(options = {}) {
 		height
 	};
 }
-
 //#endregion
-export { withDirectives as A, renderList as C, watch as D, useTemplateRef as E, unref as F, normalizeClass as I, normalizeStyle as L, reactive as M, ref as N, watchEffect as O, toRefs$1 as P, toDisplayString as R, openBlock as S, useModel as T, defineComponent as _, useWindowSize as a, onMounted as b, vShow as c, computed as d, createBaseVNode as f, createVNode as g, createElementBlock as h, useScreenSafeArea as i, markRaw as j, withCtx as k, withModifiers as l, createCommentVNode as m, useEventListener as n, toRefs as o, createBlock as p, useLocalStorage as r, defineCustomElement as s, useElementBounding as t, Fragment as u, mergeModels as v, renderSlot as w, onUnmounted as x, nextTick as y };
+export { nextTick as A, withDirectives as B, createElementBlock as C, defineAsyncComponent as D, createVNode as E, renderSlot as F, toRefs as G, reactive as H, useTemplateRef as I, normalizeStyle as J, unref as K, watch as L, onUnmounted as M, openBlock as N, defineComponent as O, renderList as P, watchEffect as R, createCommentVNode as S, createTextVNode as T, ref as U, markRaw as V, shallowRef as W, toDisplayString as Y, Fragment as _, useScreenSafeArea as a, createBaseVNode as b, useDebounceFn as c, TransitionGroup as d, defineCustomElement as f, withModifiers as g, withKeys as h, useLocalStorage as i, onMounted as j, h as k, watchDebounced as l, vShow as m, useElementBounding as n, useTimeAgo as o, vModelText as p, normalizeClass as q, useEventListener as r, useWindowSize as s, onClickOutside as t, watchImmediate as u, Suspense as v, createStaticVNode as w, createBlock as x, computed as y, withCtx as z };