@vitejs/devtools 0.0.0-alpha.3 → 0.0.0-alpha.30

package/dist/{core-uTAXYiA1.js → vue.runtime.esm-bundler-DL0i8o0W.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.27/node_modules/@vue/shared/dist/shared.esm-bundler.js
 /**
-* @vue/shared v3.5.22
+* @vue/shared v3.5.27
 * (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,16 +22,16 @@ 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 isFunction = (val) => typeof val === "function";
 const isString = (val) => typeof val === "string";
 const isSymbol = (val) => typeof val === "symbol";
-const isObject$1 = (val) => val !== null && typeof val === "object";
+const isObject = (val) => val !== null && typeof val === "object";
 const isPromise = (val) => {
-	return (isObject$1(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+	return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
 };
 const objectToString = Object.prototype.toString;
 const toTypeString = (value) => objectToString.call(value);
@@ -42,22 +42,22 @@ const isPlainObject = (val) => toTypeString(val) === "[object Object]";
 const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
 const isReservedProp = /* @__PURE__ */ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted");
 const isBuiltInDirective = /* @__PURE__ */ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo");
-const cacheStringFunction$1 = (fn) => {
+const cacheStringFunction = (fn) => {
 	const cache = /* @__PURE__ */ Object.create(null);
 	return ((str) => {
 		return cache[str] || (cache[str] = fn(str));
 	});
 };
-const camelizeRE$1 = /-\w/g;
-const camelize$1 = cacheStringFunction$1((str) => {
-	return str.replace(camelizeRE$1, (c) => c.slice(1).toUpperCase());
+const camelizeRE = /-\w/g;
+const camelize = cacheStringFunction((str) => {
+	return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
 });
-const hyphenateRE$1 = /\B([A-Z])/g;
-const hyphenate$1 = cacheStringFunction$1((str) => str.replace(hyphenateRE$1, "-$1").toLowerCase());
-const capitalize = cacheStringFunction$1((str) => {
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
+const capitalize = cacheStringFunction((str) => {
 	return str.charAt(0).toUpperCase() + str.slice(1);
 });
-const toHandlerKey = cacheStringFunction$1((str) => {
+const toHandlerKey = cacheStringFunction((str) => {
 	return str ? `on${capitalize(str)}` : ``;
 });
 const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
@@ -93,7 +93,7 @@ function normalizeStyle(value) {
 			if (normalized) for (const key in normalized) res[key] = normalized[key];
 		}
 		return res;
-	} else if (isString(value) || isObject$1(value)) return value;
+	} else if (isString(value) || isObject(value)) return value;
 }
 const listDelimiterRE = /;(?![^(]*\))/g;
 const propertyDelimiterRE = /:([^]+)/;
@@ -115,7 +115,7 @@ function normalizeClass(value) {
 		const normalized = normalizeClass(value[i]);
 		if (normalized) res += normalized + " ";
 	}
-	else if (isObject$1(value)) {
+	else if (isObject(value)) {
 		for (const name in value) if (value[name]) res += name + " ";
 	}
 	return res.trim();
@@ -136,7 +136,7 @@ const isRef$1 = (val) => {
 	return !!(val && val["__v_isRef"] === true);
 };
 const toDisplayString = (val) => {
-	return isString(val) ? val : val == null ? "" : isArray(val) || isObject$1(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
+	return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
 };
 const replacer = (_key, val) => {
 	if (isRef$1(val)) return replacer(_key, val.value);
@@ -146,7 +146,7 @@ const replacer = (_key, val) => {
 	}, {}) };
 	else if (isSet(val)) return { [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v)) };
 	else if (isSymbol(val)) return stringifySymbol(val);
-	else if (isObject$1(val) && !isArray(val) && !isPlainObject(val)) return String(val);
+	else if (isObject(val) && !isArray(val) && !isPlainObject(val)) return String(val);
 	return val;
 };
 const stringifySymbol = (v, i = "") => {
@@ -155,7 +155,12 @@ const stringifySymbol = (v, i = "") => {
 };
 
 //#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.27/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+/**
+* @vue/reactivity v3.5.27
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 function warn$2(msg, ...args) {
 	console.warn(`[Vue warn] ${msg}`, ...args);
 }
@@ -434,24 +439,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 +465,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 +533,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 +607,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 +622,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 +699,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 +730,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 +796,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 +813,53 @@ 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);
 	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);
+	if (arr !== self) {
+		if (!/* @__PURE__ */ isShallow(self)) wrappedFn = function(acc, item, index) {
+			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$1);
+			return fn.call(this, acc, item, index, self);
 		};
 	}
 	return arr[method](wrappedFn, ...args);
 }
-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 +868,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 +893,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(value) ? /* @__PURE__ */ readonly(value) : value;
 		}
-		if (isObject$1(res)) return isReadonly2 ? readonly(res) : reactive(res);
+		if (isObject(res)) return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
 		return res;
 	}
 };
@@ -902,13 +911,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 +926,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 +973,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,23 +1035,23 @@ 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 (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) value = /* @__PURE__ */ toRaw(value);
+			const target = /* @__PURE__ */ toRaw(this);
 			if (!getProto(target).has.call(target, value)) {
 				target.add(value);
 				trigger(target, "add", value, value);
@@ -1054,12 +1059,12 @@ function createInstrumentations(readonly$1, shallow) {
 			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 +1074,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 +1087,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 +1101,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 +1111,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 +1119,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,21 +1143,25 @@ 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);
 }
 function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
-	if (!isObject$1(target)) {
+	if (!isObject(target)) {
 		if (!!(process.env.NODE_ENV !== "production")) warn$2(`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(target)}`);
 		return target;
 	}
@@ -1165,40 +1174,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(value) ? /* @__PURE__ */ reactive(value) : value;
+const toReadonly = (value) => isObject(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 +1223,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 +1238,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 +1255,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 +1264,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 +1292,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 +1306,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 +1344,15 @@ var GetterRefImpl = class {
 		return this._value = this._getter();
 	}
 };
-function toRef$1(source, key, defaultValue) {
-	if (isRef(source)) return source;
+/* @__NO_SIDE_EFFECTS__ */
+function toRef(source, key, defaultValue) {
+	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 if (isObject(source) && arguments.length > 1) return propertyToRef(source, key, defaultValue);
+	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 +1419,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 +1452,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 +1487,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 +1505,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 +1517,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,40 +1536,40 @@ 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;
 }
 function traverse(value, depth = Infinity, seen) {
-	if (depth <= 0 || !isObject$1(value) || value["__v_skip"]) return value;
+	if (depth <= 0 || !isObject(value) || value["__v_skip"]) return value;
 	seen = seen || /* @__PURE__ */ new Map();
 	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);
@@ -1548,7 +1582,12 @@ function traverse(value, depth = Infinity, seen) {
 }
 
 //#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.27/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+/**
+* @vue/runtime-core v3.5.27
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 const stack = [];
 function pushWarningContext(vnode) {
 	stack.push(vnode);
@@ -1644,6 +1683,12 @@ function formatProp(key, value, raw) {
 		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 +1790,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 +2033,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 +2144,122 @@ 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");
 function setTransitionHooks(vnode, hooks) {
 	if (vnode.shapeFlag & 6 && vnode.component) {
 		vnode.transition = hooks;
@@ -2114,7 +2271,7 @@ function setTransitionHooks(vnode, hooks) {
 }
 /* @__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 = [
@@ -2153,7 +2310,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;
@@ -2164,15 +2321,15 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
 	const rawSetupState = 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) && !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);
+		return hasOwn(rawSetupState, key);
 	};
 	const canSetRef = (ref2) => {
 		return !!!(process.env.NODE_ENV !== "production") || !knownTemplateRefs.has(ref2);
 	};
-	if (oldRef != null && oldRef !== ref$1) {
+	if (oldRef != null && oldRef !== ref) {
 		invalidatePendingSetRef(oldRawRef);
 		if (isString(oldRef)) {
 			refs[oldRef] = null;
@@ -2183,31 +2340,31 @@ function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
 			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 = 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)) 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)) 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 +2378,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 +2388,130 @@ function invalidatePendingSetRef(rawRef) {
 		pendingSetRefMap.delete(rawRef);
 	}
 }
+const isComment = (node) => node.nodeType === 8;
 const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
 const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+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(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 = ref(false);
+			const error = ref();
+			const delayed = 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);
@@ -2279,10 +2557,7 @@ function injectHook(type, hook, target = currentInstance, prepend = false) {
 		if (prepend) hooks.unshift(wrappedHook);
 		else hooks.push(wrappedHook);
 		return wrappedHook;
-	} else if (!!(process.env.NODE_ENV !== "production")) {
-		const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
-		warn$1(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
-	}
+	} else if (!!(process.env.NODE_ENV !== "production")) warn$1(`${toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""))} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`);
 }
 const createHook = (lifecycle) => (hook, target = currentInstance) => {
 	if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
@@ -2299,7 +2574,7 @@ 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];
@@ -2319,7 +2594,7 @@ function renderList(source, renderItem, cache, index) {
 		if (!!(process.env.NODE_ENV !== "production") && !Number.isInteger(source)) warn$1(`The v-for range expect an integer value but got ${source}.`);
 		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(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);
@@ -2385,13 +2660,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) {
@@ -2403,13 +2677,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;
@@ -2423,12 +2697,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.`);
 		}
 	},
@@ -2437,13 +2711,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;
 		}
@@ -2458,13 +2732,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);
 	}
 };
@@ -2518,12 +2792,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);
@@ -2539,7 +2808,7 @@ function applyOptions(instance) {
 	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;
+	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;
@@ -2563,7 +2832,7 @@ function applyOptions(instance) {
 		if (!!(process.env.NODE_ENV !== "production") && !isFunction(dataOptions)) warn$1(`The data option must be a function. Plain object usage is no longer supported.`);
 		const data = dataOptions.call(publicThis, publicThis);
 		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.`);
+		if (!isObject(data)) process.env.NODE_ENV !== "production" && warn$1(`data() should return an object.`);
 		else {
 			instance.data = reactive(data);
 			if (!!(process.env.NODE_ENV !== "production")) for (const key in data) {
@@ -2582,12 +2851,11 @@ function applyOptions(instance) {
 		const opt = computedOptions[key];
 		const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
 		if (!!(process.env.NODE_ENV !== "production") && get === NOOP) warn$1(`Computed property "${key}" has no getter.`);
-		const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : !!(process.env.NODE_ENV !== "production") ? () => {
-			warn$1(`Write operation failed: computed property "${key}" is readonly.`);
-		} : NOOP;
 		const c = computed({
 			get,
-			set
+			set: !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : !!(process.env.NODE_ENV !== "production") ? () => {
+				warn$1(`Write operation failed: computed property "${key}" is readonly.`);
+			} : NOOP
 		});
 		Object.defineProperty(ctx, key, {
 			enumerable: true,
@@ -2633,7 +2901,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;
@@ -2644,7 +2912,7 @@ function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP)
 	for (const key in injectOptions) {
 		const opt = injectOptions[key];
 		let injected;
-		if (isObject$1(opt)) if ("default" in opt) injected = inject(opt.from || key, opt.default, true);
+		if (isObject(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, {
@@ -2658,7 +2926,7 @@ function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP)
 	}
 }
 function callHook(hook, instance, type) {
-	callWithAsyncErrorHandling(isArray(hook) ? hook.map((h$1) => h$1.bind(instance.proxy)) : hook.bind(instance.proxy), 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];
@@ -2667,7 +2935,7 @@ function createWatcher(raw, ctx, publicThis, key) {
 		if (isFunction(handler)) watch(getter, handler);
 		else if (!!(process.env.NODE_ENV !== "production")) warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
 	} else if (isFunction(raw)) watch(getter, raw.bind(publicThis));
-	else if (isObject$1(raw)) if (isArray(raw)) raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
+	else if (isObject(raw)) if (isArray(raw)) raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
 	else {
 		const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
 		if (isFunction(handler)) watch(getter, handler, raw);
@@ -2688,7 +2956,7 @@ function resolveMergedOptions(instance) {
 		if (globalMixins.length) globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
 		mergeOptions(resolved, base, optionMergeStrategies);
 	}
-	if (isObject$1(base)) cache.set(base, resolved);
+	if (isObject(base)) cache.set(base, resolved);
 	return resolved;
 }
 function mergeOptions(to, from, strats, asMixin = false) {
@@ -2787,10 +3055,10 @@ 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)) {
+		if (rootProps != null && !isObject(rootProps)) {
 			process.env.NODE_ENV !== "production" && warn$1(`root props passed to app.mount() must be an object.`);
 			rootProps = null;
 		}
@@ -2855,10 +3123,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;
@@ -2877,7 +3145,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);
@@ -2886,7 +3154,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;
@@ -2905,38 +3173,263 @@ 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(modelName)}Modifiers`] || props[`${hyphenate(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(event)) in propsOptions)) warn$1(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(camelize(event))}" prop.`);
+		} else {
+			const validator = emitsOptions[event];
+			if (isFunction(validator)) {
+				if (!validator(...rawArgs)) warn$1(`Invalid event arguments: event validation failed for event "${event}".`);
+			}
+		}
+	}
+	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);
+	}
+	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(event)}" instead of "${event}".`);
+	}
+	let handlerName;
+	let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize(event))];
+	if (!handler && isModelListener) handler = props[handlerName = toHandlerKey(hyphenate(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);
 	}
 }
-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.`);
+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(comp)) cache.set(comp, null);
+		return null;
+	}
+	if (isArray(raw)) raw.forEach((key) => normalized[key] = null);
+	else extend(normalized, raw);
+	if (isObject(comp)) cache.set(comp, normalized);
+	return normalized;
 }
-function hasInjectionContext() {
-	return !!(getCurrentInstance() || currentApp);
+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(key)) || hasOwn(options, key);
 }
-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);
+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") ? 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
+			} : {
+				attrs,
+				slots,
+				emit
+			}) : render2(!!(process.env.NODE_ENV !== "production") ? 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 (nextProps[key] !== 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 (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) return true;
+	}
+	return false;
+}
+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 : shallowReactive(props);
 	else if (!instance.type.props) instance.props = attrs;
 	else instance.props = props;
@@ -2960,13 +3453,13 @@ 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;
 					}
 				} else {
-					const camelizedKey = camelize$1(key);
+					const camelizedKey = camelize(key);
 					props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false);
 				}
 				else if (value !== attrs[key]) {
@@ -2978,11 +3471,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(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;
 			}
@@ -2999,7 +3492,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(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]) {
@@ -3013,7 +3506,7 @@ function setFullProps(instance, rawProps, props, attrs) {
 		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;
@@ -3021,7 +3514,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)) {
@@ -3037,7 +3530,7 @@ function resolvePropValue(options, props, key, value, instance, isAbsent) {
 		}
 		if (opt[0]) {
 			if (isAbsent && !hasDefault) value = false;
-			else if (opt[1] && (value === "" || value === hyphenate$1(key))) value = true;
+			else if (opt[1] && (value === "" || value === hyphenate(key))) value = true;
 		}
 	}
 	return value;
@@ -3063,18 +3556,18 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
 		if (comp.mixins) comp.mixins.forEach(extendProps);
 	}
 	if (!raw && !hasExtends) {
-		if (isObject$1(comp)) cache.set(comp, EMPTY_ARR);
+		if (isObject(comp)) cache.set(comp, EMPTY_ARR);
 		return EMPTY_ARR;
 	}
 	if (isArray(raw)) for (let i = 0; i < raw.length; i++) {
 		if (!!(process.env.NODE_ENV !== "production") && !isString(raw[i])) warn$1(`props must be strings when using array syntax.`, raw[i]);
-		const normalizedKey = camelize$1(raw[i]);
+		const normalizedKey = camelize(raw[i]);
 		if (validatePropName(normalizedKey)) normalized[normalizedKey] = EMPTY_OBJ;
 	}
 	else if (raw) {
-		if (!!(process.env.NODE_ENV !== "production") && !isObject$1(raw)) warn$1(`invalid props options`, raw);
+		if (!!(process.env.NODE_ENV !== "production") && !isObject(raw)) warn$1(`invalid props options`, raw);
 		for (const key in raw) {
-			const normalizedKey = camelize$1(key);
+			const normalizedKey = camelize(key);
 			if (validatePropName(normalizedKey)) {
 				const opt = raw[key];
 				const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
@@ -3092,12 +3585,12 @@ 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);
 			}
 		}
 	}
 	const res = [normalized, needCastKeys];
-	if (isObject$1(comp)) cache.set(comp, res);
+	if (isObject(comp)) cache.set(comp, res);
 	return res;
 }
 function validatePropName(key) {
@@ -3114,7 +3607,7 @@ function getType(ctor) {
 function validateProps(rawProps, props, instance) {
 	const resolvedValues = toRaw(props);
 	const options = instance.propsOptions[0];
-	const camelizePropsKey = Object.keys(rawProps).map((key) => camelize$1(key));
+	const camelizePropsKey = Object.keys(rawProps).map((key) => camelize(key));
 	for (const key in options) {
 		let opt = options[key];
 		if (opt == null) continue;
@@ -3153,7 +3646,7 @@ function assertType(value, type) {
 		const t = typeof value;
 		valid = t === expectedType.toLowerCase();
 		if (!valid && t === "object") valid = value instanceof type;
-	} else if (expectedType === "Object") valid = isObject$1(value);
+	} else if (expectedType === "Object") valid = isObject(value);
 	else if (expectedType === "Array") valid = isArray(value);
 	else valid = value instanceof type;
 	return {
@@ -3323,7 +3816,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);
@@ -3344,14 +3837,20 @@ 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);
 		else {
 			const el = n2.el = n1.el;
-			if (n2.children !== n1.children) hostSetText(el, n2.children);
+			if (n2.children !== n1.children) if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating && n2.patchFlag === -1 && "__elIndex" in n1) {
+				const childNodes = container.childNodes;
+				const newChild = hostCreateText(n2.children);
+				const oldChild = childNodes[n2.__elIndex = n1.__elIndex];
+				hostInsert(newChild, container, oldChild);
+				hostRemove(oldChild);
+			} else hostSetText(el, n2.children);
 		}
 	};
 	const processCommentNode = (n1, n2, container, anchor) => {
@@ -3393,7 +3892,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;
@@ -3436,10 +3943,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 		}
 	};
 	const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
-		for (let i = start; i < children.length; i++) {
-			const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
-			patch(null, child, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-		}
+		for (let i = start; i < children.length; i++) patch(null, children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]), container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
 	};
 	const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
 		const el = n2.el = n1.el;
@@ -3493,8 +3997,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 		for (let i = 0; i < newChildren.length; i++) {
 			const oldVNode = oldChildren[i];
 			const newVNode = newChildren[i];
-			const container = oldVNode.el && (oldVNode.type === Fragment || !isSameVNodeType(oldVNode, newVNode) || oldVNode.shapeFlag & 198) ? hostParentNode(oldVNode.el) : fallbackContainer;
-			patch(oldVNode, newVNode, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, true);
+			patch(oldVNode, newVNode, oldVNode.el && (oldVNode.type === Fragment || !isSameVNodeType(oldVNode, newVNode) || oldVNode.shapeFlag & 198) ? hostParentNode(oldVNode.el) : fallbackContainer, null, parentComponent, parentSuspense, namespace, slotScopeIds, true);
 		}
 	};
 	const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
@@ -3525,7 +4028,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);
@@ -3662,17 +4165,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();
 	};
@@ -3803,7 +4306,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--;
@@ -3857,11 +4360,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;
@@ -3883,19 +4386,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;
@@ -3952,14 +4455,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;
 		}
@@ -3968,7 +4475,7 @@ function baseCreateRenderer(options, createHydrationFns) {
 		p: patch,
 		um: unmount,
 		m: move,
-		r: remove$1,
+		r: remove,
 		mt: mountComponent,
 		mc: mountChildren,
 		pc: patchChildren,
@@ -3980,20 +4487,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;
 	}
 }
@@ -4013,13 +4520,14 @@ 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.el = c1.el;
+		else c2.__elIndex = i + (n1.type === Fragment ? 1 : 0);
 		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;
@@ -4028,7 +4536,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;
 			}
@@ -4040,7 +4548,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;
 			}
 		}
@@ -4049,7 +4557,7 @@ function getSequence(arr) {
 	v = result[u - 1];
 	while (u-- > 0) {
 		result[u] = v;
-		v = p$1[v];
+		v = p[v];
 	}
 	return result;
 }
@@ -4061,412 +4569,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();
-				}
-				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`];
+	},
+	hydrate: hydrateSuspense,
+	normalize: normalizeSuspenseChildren
 };
-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}".`);
-			}
-		}
-	}
-	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);
-	}
-}
-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);
+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);
+				}
 			}
-		};
-		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$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);
-		}
-	} 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);
+			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);
 				}
-				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 (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) return true;
+			} 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();
 			}
 		}
-	} else {
-		if (prevChildren || nextChildren) {
-			if (!nextChildren || !nextChildren.$stable) return true;
+	} 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);
 		}
-		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 (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) return true;
+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.`);
 	}
-	return false;
+	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++;
+		}
+	}
+	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 (!delayEnter) move(pendingBranch, container2, anchor, 0);
+			}
+			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;
+			}
+			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);
+		}
+	};
+	return suspense;
 }
-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 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 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) {
@@ -4512,14 +4916,14 @@ const createVNodeWithArgsTransform = (...args) => {
 	return _createVNode(...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : 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) || 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 = {
@@ -4578,12 +4982,12 @@ function _createVNode(type, props = null, children = null, patchFlag = 0, dynami
 		props = guardReactiveProps(props);
 		let { class: klass, style } = props;
 		if (klass && !isString(klass)) props.class = normalizeClass(klass);
-		if (isObject$1(style)) {
+		if (isObject(style)) {
 			if (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;
+	const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
 	if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
 		type = 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\`.`, `
@@ -4596,7 +5000,7 @@ function guardReactiveProps(props) {
 	return 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,
@@ -4604,7 +5008,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,
@@ -4640,6 +5044,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);
 }
@@ -4835,7 +5244,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);
@@ -4871,10 +5279,7 @@ function setupStatefulComponent(instance, isSSR) {
 			});
 			else {
 				instance.asyncDep = setupResult;
-				if (!!(process.env.NODE_ENV !== "production") && !instance.suspense) {
-					const name = (_a = Component.name) != null ? _a : "Anonymous";
-					warn$1(`Component <${name}>: 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);
@@ -4882,7 +5287,7 @@ function setupStatefulComponent(instance, isSSR) {
 function handleSetupResult(instance, setupResult, isSSR) {
 	if (isFunction(setupResult)) if (instance.type.__ssrInlineRender) instance.ssrRender = setupResult;
 	else instance.render = setupResult;
-	else if (isObject$1(setupResult)) {
+	else if (isObject(setupResult)) {
 		if (!!(process.env.NODE_ENV !== "production") && isVNode(setupResult)) warn$1(`setup() should not return VNodes directly - return a render function instead.`);
 		if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) instance.devtoolsRawSetupState = setupResult;
 		instance.setupState = proxyRefs(setupResult);
@@ -5010,11 +5415,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`;
 }
@@ -5029,6 +5434,23 @@ const computed = (getterOrOptions, debugOptions) => {
 	}
 	return c;
 };
+function h(type, propsOrChildren, children) {
+	try {
+		setBlockTracking(-1);
+		const l = arguments.length;
+		if (l === 2) if (isObject(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" };
@@ -5038,7 +5460,7 @@ function initCustomFormatter() {
 	const formatter = {
 		__vue_custom_formatter: true,
 		header(obj) {
-			if (!isObject$1(obj)) return null;
+			if (!isObject(obj)) return null;
 			if (obj.__isVue) return [
 				"div",
 				vueStyle,
@@ -5102,8 +5524,8 @@ function initCustomFormatter() {
 		if (instance.type.props && instance.props) blocks.push(createInstanceBlock("props", 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));
+		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([
@@ -5163,7 +5585,7 @@ function initCustomFormatter() {
 			keywordStyle,
 			v
 		];
-		else if (isObject$1(v)) return ["object", { object: asRaw ? toRaw(v) : v }];
+		else if (isObject(v)) return ["object", { object: asRaw ? toRaw(v) : v }];
 		else return [
 			"span",
 			stringStyle,
@@ -5179,7 +5601,7 @@ function initCustomFormatter() {
 	}
 	function isKeyOfType(Comp, key, type) {
 		const opts = Comp[type];
-		if (isArray(opts) && opts.includes(key) || isObject$1(opts) && key in opts) return true;
+		if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) return true;
 		if (Comp.extends && isKeyOfType(Comp.extends, key, type)) return true;
 		if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) return true;
 	}
@@ -5191,13 +5613,18 @@ function initCustomFormatter() {
 	if (window.devtoolsFormatters) window.devtoolsFormatters.push(formatter);
 	else window.devtoolsFormatters = [formatter];
 }
-const version = "3.5.22";
+const version = "3.5.27";
 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);
 
 //#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.27/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
+/**
+* @vue/runtime-dom v3.5.27
+* (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 {
@@ -5256,7 +5683,7 @@ const nodeOps = {
 		return [before ? before.nextSibling : parent.firstChild, anchor ? anchor.previousSibling : parent.lastChild];
 	}
 };
-const vtcKey = Symbol("_vtc");
+const vtcKey = /* @__PURE__ */ Symbol("_vtc");
 function patchClass(el, value, isSVG) {
 	const transitionClasses = el[vtcKey];
 	if (transitionClasses) value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
@@ -5264,8 +5691,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 }) {
@@ -5295,7 +5722,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;
@@ -5337,7 +5764,7 @@ function setStyle(style, name, val) {
 		if (name.startsWith("--")) style.setProperty(name, val);
 		else {
 			const prefixed = autoPrefix(style, name);
-			if (importantRE.test(val)) style.setProperty(hyphenate$1(prefixed), val.replace(importantRE, ""), "important");
+			if (importantRE.test(val)) style.setProperty(hyphenate(prefixed), val.replace(importantRE, ""), "important");
 			else style[prefixed] = val;
 		}
 	}
@@ -5351,7 +5778,7 @@ const prefixCache = {};
 function autoPrefix(style, rawName) {
 	const cached = prefixCache[rawName];
 	if (cached) return cached;
-	let name = camelize$1(rawName);
+	let name = camelize(rawName);
 	if (name !== "filter" && name in style) return prefixCache[rawName] = name;
 	name = capitalize(name);
 	for (let i = 0; i < prefixes.length; i++) {
@@ -5361,11 +5788,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") {
@@ -5406,17 +5833,15 @@ 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];
 	if (nextValue && existingInvoker) existingInvoker.value = !!(process.env.NODE_ENV !== "production") ? sanitizeEventValue(nextValue, rawName) : nextValue;
 	else {
 		const [name, options] = parseName(rawName);
-		if (nextValue) {
-			const invoker = invokers[rawName] = createInvoker(!!(process.env.NODE_ENV !== "production") ? sanitizeEventValue(nextValue, rawName) : nextValue, instance);
-			addEventListener(el, name, invoker, options);
-		} else if (existingInvoker) {
+		if (nextValue) addEventListener(el, name, invokers[rawName] = createInvoker(!!(process.env.NODE_ENV !== "production") ? sanitizeEventValue(nextValue, rawName) : nextValue, instance), options);
+		else if (existingInvoker) {
 			removeEventListener(el, name, existingInvoker, options);
 			invokers[rawName] = void 0;
 		}
@@ -5433,7 +5858,7 @@ function parseName(name) {
 			options[m[0].toLowerCase()] = true;
 		}
 	}
-	return [name[2] === ":" ? name.slice(3) : hyphenate$1(name.slice(2)), options];
+	return [name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2)), options];
 }
 let cachedNow = 0;
 const p = /* @__PURE__ */ Promise.resolve();
@@ -5474,7 +5899,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 && (/[A-Z]/.test(key) || !isString(nextValue))) patchDOMProp(el, camelize(key), nextValue, parentComponent, key);
 	else {
 		if (key === "true-value") el._trueValue = nextValue;
 		else if (key === "false-value") el._falseValue = nextValue;
@@ -5488,6 +5913,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;
@@ -5533,6 +5959,8 @@ 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._ob = null;
@@ -5599,53 +6027,53 @@ 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];
 				if (opt === Number || opt && opt.type === Number) {
 					if (key in this._props) this._props[key] = toNumber(this._props[key]);
-					(numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize$1(key)] = true;
+					(numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
 				}
 			}
 			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, {
+		for (const key of declaredPropKeys.map(camelize)) Object.defineProperty(this, key, {
 			get() {
 				return this._getProp(key);
 			},
 			set(val) {
-				this._setProp(key, val, true, true);
+				this._setProp(key, val, true, !this._patching);
 			}
 		});
 	}
@@ -5653,7 +6081,7 @@ var VueElement = class VueElement extends BaseClass {
 		if (key.startsWith("data-v-")) return;
 		const has = this.hasAttribute(key);
 		let value = has ? this.getAttribute(key) : REMOVAL;
-		const camelKey = camelize$1(key);
+		const camelKey = camelize(key);
 		if (has && this._numberProps && this._numberProps[camelKey]) value = toNumber(value);
 		this._setProp(camelKey, value, false, true);
 	}
@@ -5668,6 +6096,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;
@@ -5680,9 +6109,9 @@ var VueElement = class VueElement extends BaseClass {
 					this._processMutations(ob.takeRecords());
 					ob.disconnect();
 				}
-				if (val === true) this.setAttribute(hyphenate$1(key), "");
-				else if (typeof val === "string" || typeof val === "number") this.setAttribute(hyphenate$1(key), val + "");
-				else if (!val) this.removeAttribute(hyphenate$1(key));
+				if (val === true) this.setAttribute(hyphenate(key), "");
+				else if (typeof val === "string" || typeof val === "number") this.setAttribute(hyphenate(key), val + "");
+				else if (!val) this.removeAttribute(hyphenate(key));
 				ob && ob.observe(this, { attributes: true });
 			}
 		}
@@ -5714,7 +6143,7 @@ var VueElement = class VueElement extends BaseClass {
 			};
 			instance.emit = (event, ...args) => {
 				dispatch(event, args);
-				if (hyphenate$1(event) !== event) dispatch(hyphenate$1(event), args);
+				if (hyphenate(event) !== event) dispatch(hyphenate(event), args);
 			};
 			this._setParent();
 		};
@@ -5785,10 +6214,12 @@ 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
@@ -5799,6 +6230,20 @@ var VueElement = class VueElement extends BaseClass {
 	/**
 	* @internal
 	*/
+	_beginPatch() {
+		this._patching = true;
+		this._dirty = false;
+	}
+	/**
+	* @internal
+	*/
+	_endPatch() {
+		this._patching = false;
+		if (this._dirty && this._instance) this._update();
+	}
+	/**
+	* @internal
+	*/
 	_removeChildStyle(comp) {
 		if (!!(process.env.NODE_ENV !== "production")) {
 			this._styleChildren.delete(comp);
@@ -5812,9 +6257,6 @@ var VueElement = class VueElement extends BaseClass {
 		}
 	}
 };
-const moveCbKey = Symbol("_moveCb");
-const enterCbKey = Symbol("_enterCb");
-const assignKey = Symbol("_assign");
 const systemModifiers = [
 	"ctrl",
 	"shift",
@@ -5845,6 +6287,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(event.key);
+		if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) return fn(event);
+	}));
+};
 const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
 let renderer;
 function ensureRenderer() {
@@ -5923,728 +6383,16 @@ function normalizeContainer(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.27_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+/**
+* vue v3.5.27
+* (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@13.9.0_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/shared/index.mjs
-function tryOnScopeDispose(fn) {
-	if (getCurrentScope()) {
-		onScopeDispose(fn);
-		return true;
-	}
-	return false;
-}
-const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
-const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
-	var _a;
-	const key = args[0];
-	const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
-	if (instance == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
-	if (instance && localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance)) return localProvidedStateMap.get(instance)[key];
-	return inject(...args);
-};
-const isClient = typeof window !== "undefined" && typeof document !== "undefined";
-const isWorker = 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 = () => {};
-function toRef(...args) {
-	if (args.length !== 1) return toRef$1(...args);
-	const r = args[0];
-	return typeof r === "function" ? readonly(customRef(() => ({
-		get: r,
-		set: noop
-	}))) : ref(r);
-}
-function createFilterWrapper(filter, fn) {
-	function wrapper(...args) {
-		return new Promise((resolve, reject) => {
-			Promise.resolve(filter(() => fn.apply(this, args), {
-				fn,
-				thisArg: this,
-				args
-			})).then(resolve).catch(reject);
-		});
-	}
-	return wrapper;
-}
-const bypassFilter = (invoke) => {
-	return invoke();
-};
-function debounceFilter(ms, options = {}) {
-	let timer;
-	let maxTimer;
-	let lastRejector = noop;
-	const _clearTimeout = (timer2) => {
-		clearTimeout(timer2);
-		lastRejector();
-		lastRejector = noop;
-	};
-	let lastInvoker;
-	const filter = (invoke) => {
-		const duration = toValue(ms);
-		const maxDuration = toValue(options.maxWait);
-		if (timer) _clearTimeout(timer);
-		if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
-			if (maxTimer) {
-				_clearTimeout(maxTimer);
-				maxTimer = void 0;
-			}
-			return Promise.resolve(invoke());
-		}
-		return new Promise((resolve, reject) => {
-			lastRejector = options.rejectOnCancel ? reject : resolve;
-			lastInvoker = invoke;
-			if (maxDuration && !maxTimer) maxTimer = setTimeout(() => {
-				if (timer) _clearTimeout(timer);
-				maxTimer = void 0;
-				resolve(lastInvoker());
-			}, maxDuration);
-			timer = setTimeout(() => {
-				if (maxTimer) _clearTimeout(maxTimer);
-				maxTimer = void 0;
-				resolve(invoke());
-			}, duration);
-		});
-	};
-	return filter;
-}
-function pausableFilter(extendFilter = bypassFilter, options = {}) {
-	const { initialState = "active" } = options;
-	const isActive = toRef(initialState === "active");
-	function pause() {
-		isActive.value = false;
-	}
-	function resume() {
-		isActive.value = true;
-	}
-	const eventFilter = (...args) => {
-		if (isActive.value) extendFilter(...args);
-	};
-	return {
-		isActive: readonly(isActive),
-		pause,
-		resume,
-		eventFilter
-	};
-}
-function pxValue(px) {
-	return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
-}
-function toArray(value) {
-	return Array.isArray(value) ? value : [value];
-}
-function cacheStringFunction(fn) {
-	const cache = /* @__PURE__ */ Object.create(null);
-	return (str) => {
-		return cache[str] || (cache[str] = fn(str));
-	};
-}
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
-const camelizeRE = /-(\w)/g;
-const camelize = cacheStringFunction((str) => {
-	return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-});
-function getLifeCycleTarget(target) {
-	return target || getCurrentInstance();
-}
-/* @__NO_SIDE_EFFECTS__ */
-function useDebounceFn(fn, ms = 200, options = {}) {
-	return createFilterWrapper(debounceFilter(ms, options), fn);
-}
-function watchWithFilter(source, cb, options = {}) {
-	const { eventFilter = bypassFilter,...watchOptions } = options;
-	return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
-}
-function watchPausable(source, cb, options = {}) {
-	const { eventFilter: filter, initialState = "active",...watchOptions } = options;
-	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
-	return {
-		stop: watchWithFilter(source, cb, {
-			...watchOptions,
-			eventFilter
-		}),
-		pause,
-		resume,
-		isActive
-	};
-}
-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 _a;
-			if ((_a = toValue(options.replaceRef)) != null ? _a : 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;
-}
-function tryOnMounted(fn, sync = true, target) {
-	if (getLifeCycleTarget(target)) onMounted(fn, target);
-	else if (sync) fn();
-	else nextTick(fn);
-}
-function watchImmediate(source, cb, options) {
-	return watch(source, cb, {
-		...options,
-		immediate: true
-	});
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@vueuse+core@13.9.0_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.mjs
-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;
-function unrefElement(elRef) {
-	var _a;
-	const plain = toValue(elRef);
-	return (_a = plain == null ? void 0 : plain.$el) != null ? _a : 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);
-	};
-	const firstParamTargets = computed(() => {
-		const test = toArray(toValue(args[0])).filter((e) => e != null);
-		return test.every((e) => typeof e !== "string") ? test : void 0;
-	});
-	const stopWatch = watchImmediate(() => {
-		var _a, _b;
-		return [
-			(_b = (_a = firstParamTargets.value) == null ? void 0 : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null),
-			toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
-			toArray(unref(firstParamTargets.value ? args[2] : args[1])),
-			toValue(firstParamTargets.value ? args[3] : args[2])
-		];
-	}, ([raw_targets, raw_events, raw_listeners, raw_options]) => {
-		cleanup();
-		if (!(raw_targets == null ? void 0 : raw_targets.length) || !(raw_events == null ? void 0 : raw_events.length) || !(raw_listeners == null ? 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)))));
-	}, { flush: "post" });
-	const stop$1 = () => {
-		stopWatch();
-		cleanup();
-	};
-	tryOnScopeDispose(cleanup);
-	return stop$1;
-}
-/* @__NO_SIDE_EFFECTS__ */
-function useMounted() {
-	const isMounted = shallowRef(false);
-	const instance = getCurrentInstance();
-	if (instance) onMounted(() => {
-		isMounted.value = true;
-	}, instance);
-	return isMounted;
-}
-/* @__NO_SIDE_EFFECTS__ */
-function useSupported(callback) {
-	const isMounted = /* @__PURE__ */ useMounted();
-	return computed(() => {
-		isMounted.value;
-		return Boolean(callback());
-	});
-}
-function useMutationObserver(target, callback, options = {}) {
-	const { window: window$1 = defaultWindow,...mutationOptions } = options;
-	let observer;
-	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "MutationObserver" in window$1);
-	const cleanup = () => {
-		if (observer) {
-			observer.disconnect();
-			observer = void 0;
-		}
-	};
-	const targets = computed(() => {
-		const value = toValue(target);
-		const items = toArray(value).map(unrefElement).filter(notNullish);
-		return new Set(items);
-	});
-	const stopWatch = watch(targets, (newTargets) => {
-		cleanup();
-		if (isSupported$1.value && newTargets.size) {
-			observer = new MutationObserver(callback);
-			newTargets.forEach((el) => observer.observe(el, mutationOptions));
-		}
-	}, {
-		immediate: true,
-		flush: "post"
-	});
-	const takeRecords = () => {
-		return observer == null ? void 0 : observer.takeRecords();
-	};
-	const stop$1 = () => {
-		stopWatch();
-		cleanup();
-	};
-	tryOnScopeDispose(stop$1);
-	return {
-		isSupported: isSupported$1,
-		stop: stop$1,
-		takeRecords
-	};
-}
-const ssrWidthSymbol = Symbol("vueuse-ssr-width");
-/* @__NO_SIDE_EFFECTS__ */
-function useSSRWidth() {
-	const ssrWidth = hasInjectionContext() ? injectLocal(ssrWidthSymbol, null) : null;
-	return typeof ssrWidth === "number" ? ssrWidth : void 0;
-}
-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 handler = (event) => {
-		matches.value = event.matches;
-	};
-	watchEffect(() => {
-		if (ssrSupport.value) {
-			ssrSupport.value = !isSupported$1.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*)\)/);
-				const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
-				let res = Boolean(minWidth || maxWidth);
-				if (minWidth && res) res = ssrWidth >= pxValue(minWidth[1]);
-				if (maxWidth && res) res = ssrWidth <= pxValue(maxWidth[1]);
-				return not ? !res : res;
-			});
-			return;
-		}
-		if (!isSupported$1.value) return;
-		mediaQuery.value = window$1.matchMedia(toValue(query));
-		matches.value = mediaQuery.value.matches;
-	});
-	useEventListener(mediaQuery, "change", handler, { passive: true });
-	return computed(() => matches.value);
-}
-const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-const globalKey = "__vueuse_ssr_handlers__";
-const handlers = /* @__PURE__ */ getHandlers();
-function getHandlers() {
-	if (!(globalKey in _global)) _global[globalKey] = _global[globalKey] || {};
-	return _global[globalKey];
-}
-function getSSRHandler(key, fallback) {
-	return handlers[key] || fallback;
-}
-function guessSerializerType(rawInit) {
-	return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
-}
-const StorageSerializers = {
-	boolean: {
-		read: (v) => v === "true",
-		write: (v) => String(v)
-	},
-	object: {
-		read: (v) => JSON.parse(v),
-		write: (v) => JSON.stringify(v)
-	},
-	number: {
-		read: (v) => Number.parseFloat(v),
-		write: (v) => String(v)
-	},
-	any: {
-		read: (v) => v,
-		write: (v) => String(v)
-	},
-	string: {
-		read: (v) => v,
-		write: (v) => String(v)
-	},
-	map: {
-		read: (v) => new Map(JSON.parse(v)),
-		write: (v) => JSON.stringify(Array.from(v.entries()))
-	},
-	set: {
-		read: (v) => new Set(JSON.parse(v)),
-		write: (v) => JSON.stringify(Array.from(v))
-	},
-	date: {
-		read: (v) => new Date(v),
-		write: (v) => v.toISOString()
-	}
-};
-const customStorageEventName = "vueuse-storage";
-function useStorage(key, defaults, storage, options = {}) {
-	var _a;
-	const { flush = "pre", deep = true, listenToStorageChanges = true, writeDefaults = true, mergeDefaults = false, shallow, window: window$1 = defaultWindow, eventFilter, onError = (e) => {
-		console.error(e);
-	}, initOnMounted } = options;
-	const data = (shallow ? shallowRef : ref)(typeof defaults === "function" ? defaults() : defaults);
-	const keyComputed = computed(() => toValue(key));
-	if (!storage) try {
-		storage = getSSRHandler("getDefaultStorage", () => {
-			var _a2;
-			return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;
-		})();
-	} catch (e) {
-		onError(e);
-	}
-	if (!storage) return data;
-	const rawInit = toValue(defaults);
-	const type = guessSerializerType(rawInit);
-	const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];
-	const { pause: pauseWatch, resume: resumeWatch } = watchPausable(data, (newValue) => write(newValue), {
-		flush,
-		deep,
-		eventFilter
-	});
-	watch(keyComputed, () => update(), { flush });
-	let firstMounted = false;
-	const onStorageEvent = (ev) => {
-		if (initOnMounted && !firstMounted) return;
-		update(ev);
-	};
-	const onStorageCustomEvent = (ev) => {
-		if (initOnMounted && !firstMounted) return;
-		updateFromCustomEvent(ev);
-	};
-	if (window$1 && listenToStorageChanges) if (storage instanceof Storage) useEventListener(window$1, "storage", onStorageEvent, { passive: true });
-	else useEventListener(window$1, customStorageEventName, onStorageCustomEvent);
-	if (initOnMounted) tryOnMounted(() => {
-		firstMounted = true;
-		update();
-	});
-	else update();
-	function dispatchWriteEvent(oldValue, newValue) {
-		if (window$1) {
-			const payload = {
-				key: keyComputed.value,
-				oldValue,
-				newValue,
-				storageArea: storage
-			};
-			window$1.dispatchEvent(storage instanceof Storage ? new StorageEvent("storage", payload) : new CustomEvent(customStorageEventName, { detail: payload }));
-		}
-	}
-	function write(v) {
-		try {
-			const oldValue = storage.getItem(keyComputed.value);
-			if (v == null) {
-				dispatchWriteEvent(oldValue, null);
-				storage.removeItem(keyComputed.value);
-			} else {
-				const serialized = serializer.write(v);
-				if (oldValue !== serialized) {
-					storage.setItem(keyComputed.value, serialized);
-					dispatchWriteEvent(oldValue, serialized);
-				}
-			}
-		} catch (e) {
-			onError(e);
-		}
-	}
-	function read(event) {
-		const rawValue = event ? event.newValue : storage.getItem(keyComputed.value);
-		if (rawValue == null) {
-			if (writeDefaults && rawInit != null) storage.setItem(keyComputed.value, serializer.write(rawInit));
-			return rawInit;
-		} else if (!event && mergeDefaults) {
-			const value = serializer.read(rawValue);
-			if (typeof mergeDefaults === "function") return mergeDefaults(value, rawInit);
-			else if (type === "object" && !Array.isArray(value)) return {
-				...rawInit,
-				...value
-			};
-			return value;
-		} else if (typeof rawValue !== "string") return rawValue;
-		else return serializer.read(rawValue);
-	}
-	function update(event) {
-		if (event && event.storageArea !== storage) return;
-		if (event && event.key == null) {
-			data.value = rawInit;
-			return;
-		}
-		if (event && event.key !== keyComputed.value) return;
-		pauseWatch();
-		try {
-			const serializedData = serializer.write(data.value);
-			if (event === void 0 || (event == null ? void 0 : event.newValue) !== serializedData) data.value = read(event);
-		} catch (e) {
-			onError(e);
-		} finally {
-			if (event) nextTick(resumeWatch);
-			else resumeWatch();
-		}
-	}
-	function updateFromCustomEvent(event) {
-		update(event.detail);
-	}
-	return data;
-}
-function useCssVar(prop, target, options = {}) {
-	const { window: window$1 = defaultWindow, initialValue, observe = false } = options;
-	const variable = shallowRef(initialValue);
-	const elRef = computed(() => {
-		var _a;
-		return unrefElement(target) || ((_a = window$1 == null ? void 0 : window$1.document) == null ? void 0 : _a.documentElement);
-	});
-	function updateCssVar() {
-		var _a;
-		const key = toValue(prop);
-		const el = toValue(elRef);
-		if (el && window$1 && key) variable.value = ((_a = window$1.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim()) || variable.value || initialValue;
-	}
-	if (observe) useMutationObserver(elRef, updateCssVar, {
-		attributeFilter: ["style", "class"],
-		window: window$1
-	});
-	watch([elRef, () => toValue(prop)], (_, old) => {
-		if (old[0] && old[1]) old[0].style.removeProperty(old[1]);
-		updateCssVar();
-	}, { immediate: true });
-	watch([variable, elRef], ([val, el]) => {
-		const raw_prop = toValue(prop);
-		if ((el == null ? void 0 : el.style) && raw_prop) if (val == null) el.style.removeProperty(raw_prop);
-		else el.style.setProperty(raw_prop, val);
-	}, { immediate: true });
-	return variable;
-}
-function useResizeObserver(target, callback, options = {}) {
-	const { window: window$1 = defaultWindow,...observerOptions } = options;
-	let observer;
-	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "ResizeObserver" in window$1);
-	const cleanup = () => {
-		if (observer) {
-			observer.disconnect();
-			observer = void 0;
-		}
-	};
-	const targets = computed(() => {
-		const _targets = toValue(target);
-		return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
-	});
-	const stopWatch = watch(targets, (els) => {
-		cleanup();
-		if (isSupported$1.value && window$1) {
-			observer = new ResizeObserver(callback);
-			for (const _el of els) if (_el) observer.observe(_el, observerOptions);
-		}
-	}, {
-		immediate: true,
-		flush: "post"
-	});
-	const stop$1 = () => {
-		cleanup();
-		stopWatch();
-	};
-	tryOnScopeDispose(stop$1);
-	return {
-		isSupported: isSupported$1,
-		stop: stop$1
-	};
-}
-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);
-	function recalculate() {
-		const el = unrefElement(target);
-		if (!el) {
-			if (reset) {
-				height.value = 0;
-				bottom.value = 0;
-				left.value = 0;
-				right.value = 0;
-				top.value = 0;
-				width.value = 0;
-				x.value = 0;
-				y.value = 0;
-			}
-			return;
-		}
-		const rect = el.getBoundingClientRect();
-		height.value = rect.height;
-		bottom.value = rect.bottom;
-		left.value = rect.left;
-		right.value = rect.right;
-		top.value = rect.top;
-		width.value = rect.width;
-		x.value = rect.x;
-		y.value = rect.y;
-	}
-	function update() {
-		if (updateTiming === "sync") recalculate();
-		else if (updateTiming === "next-frame") requestAnimationFrame(() => recalculate());
-	}
-	useResizeObserver(target, update);
-	watch(() => unrefElement(target), (ele) => !ele && update());
-	useMutationObserver(target, update, { attributeFilter: ["style", "class"] });
-	if (windowScroll) useEventListener("scroll", update, {
-		capture: true,
-		passive: true
-	});
-	if (windowResize) useEventListener("resize", update, { passive: true });
-	tryOnMounted(() => {
-		if (immediate) update();
-	});
-	return {
-		height,
-		bottom,
-		left,
-		right,
-		top,
-		width,
-		x,
-		y,
-		update
-	};
-}
-function useLocalStorage(key, initialValue, options = {}) {
-	const { window: window$1 = defaultWindow } = options;
-	return useStorage(key, initialValue, window$1 == null ? void 0 : window$1.localStorage, options);
-}
-const topVarName = "--vueuse-safe-area-top";
-const rightVarName = "--vueuse-safe-area-right";
-const bottomVarName = "--vueuse-safe-area-bottom";
-const leftVarName = "--vueuse-safe-area-left";
-function useScreenSafeArea() {
-	const top = shallowRef("");
-	const right = shallowRef("");
-	const bottom = shallowRef("");
-	const left = shallowRef("");
-	if (isClient) {
-		const topCssVar = useCssVar(topVarName);
-		const rightCssVar = useCssVar(rightVarName);
-		const bottomCssVar = useCssVar(bottomVarName);
-		const leftCssVar = useCssVar(leftVarName);
-		topCssVar.value = "env(safe-area-inset-top, 0px)";
-		rightCssVar.value = "env(safe-area-inset-right, 0px)";
-		bottomCssVar.value = "env(safe-area-inset-bottom, 0px)";
-		leftCssVar.value = "env(safe-area-inset-left, 0px)";
-		tryOnMounted(update);
-		useEventListener("resize", useDebounceFn(update), { passive: true });
-	}
-	function update() {
-		top.value = getValue(topVarName);
-		right.value = getValue(rightVarName);
-		bottom.value = getValue(bottomVarName);
-		left.value = getValue(leftVarName);
-	}
-	return {
-		top,
-		right,
-		bottom,
-		left,
-		update
-	};
-}
-function getValue(position) {
-	return getComputedStyle(document.documentElement).getPropertyValue(position);
-}
-const DEFAULT_UNITS = [
-	{
-		max: 6e4,
-		value: 1e3,
-		name: "second"
-	},
-	{
-		max: 276e4,
-		value: 6e4,
-		name: "minute"
-	},
-	{
-		max: 72e6,
-		value: 36e5,
-		name: "hour"
-	},
-	{
-		max: 5184e5,
-		value: 864e5,
-		name: "day"
-	},
-	{
-		max: 24192e5,
-		value: 6048e5,
-		name: "week"
-	},
-	{
-		max: 28512e6,
-		value: 2592e6,
-		name: "month"
-	},
-	{
-		max: Number.POSITIVE_INFINITY,
-		value: 31536e6,
-		name: "year"
-	}
-];
-/* @__NO_SIDE_EFFECTS__ */
-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 update = () => {
-		if (window$1) if (type === "outer") {
-			width.value = window$1.outerWidth;
-			height.value = window$1.outerHeight;
-		} else if (type === "visual" && window$1.visualViewport) {
-			const { width: visualViewportWidth, height: visualViewportHeight, scale } = window$1.visualViewport;
-			width.value = Math.round(visualViewportWidth * scale);
-			height.value = Math.round(visualViewportHeight * scale);
-		} else if (includeScrollbar) {
-			width.value = window$1.innerWidth;
-			height.value = window$1.innerHeight;
-		} else {
-			width.value = window$1.document.documentElement.clientWidth;
-			height.value = window$1.document.documentElement.clientHeight;
-		}
-	};
-	update();
-	tryOnMounted(update);
-	const listenerOptions = { passive: true };
-	useEventListener("resize", update, listenerOptions);
-	if (window$1 && type === "visual" && window$1.visualViewport) useEventListener(window$1.visualViewport, "resize", update, listenerOptions);
-	if (listenOrientation) {
-		const matches = useMediaQuery("(orientation: portrait)");
-		watch(matches, () => update());
-	}
-	return {
-		width,
-		height
-	};
-}
-
-//#endregion
-export { Fragment, computed, createBaseVNode, createBlock, createCommentVNode, createElementBlock, createVNode, defineComponent, defineCustomElement, markRaw, mergeModels, nextTick, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, reactive, ref, renderList, renderSlot, toDisplayString, toRefs, toRefs$1, unref, useElementBounding, useEventListener, useLocalStorage, useModel, useScreenSafeArea, useTemplateRef, useWindowSize, vShow, watch, watchEffect, withCtx, withDirectives, withModifiers };
+export { withCtx as A, toRef as B, onUnmounted as C, useTemplateRef as D, renderSlot as E, onScopeDispose as F, normalizeStyle as G, toValue as H, reactive as I, toDisplayString as K, readonly as L, customRef as M, getCurrentScope as N, watch as O, markRaw as P, ref as R, onMounted as S, renderList as T, unref as U, toRefs as V, normalizeClass as W, getCurrentInstance as _, Fragment as a, inject as b, createBaseVNode as c, createElementBlock as d, createStaticVNode as f, defineComponent as g, defineAsyncComponent as h, withModifiers as i, withDirectives as j, watchEffect as k, createBlock as l, createVNode as m, vShow as n, Suspense as o, createTextVNode as p, withKeys as r, computed as s, defineCustomElement as t, createCommentVNode as u, h as v, openBlock as w, nextTick as x, hasInjectionContext as y, shallowRef as z };