@vitejs/devtools 0.0.0-alpha.2 → 0.0.0-alpha.20

package/dist/{core-uTAXYiA1.js → docks-B3cDUs1u.js}

@@ -1,6 +1,8 @@
-//#region ../../node_modules/.pnpm/@vue+shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js
+import { createEventEmitter } from "@vitejs/devtools-kit/utils/events";
+
+//#region ../../node_modules/.pnpm/@vue+shared@3.5.25/node_modules/@vue/shared/dist/shared.esm-bundler.js
 /**
-* @vue/shared v3.5.22
+* @vue/shared v3.5.25
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -155,7 +157,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.25/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+/**
+* @vue/reactivity v3.5.25
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 function warn$2(msg, ...args) {
 	console.warn(`[Vue warn] ${msg}`, ...args);
 }
@@ -703,17 +710,21 @@ function shallowReadArray(arr) {
 	track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
 	return arr;
 }
+function toWrapped(target, item) {
+	if (isReadonly(target)) return 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 +732,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,7 +798,7 @@ 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) {
@@ -815,7 +826,7 @@ function apply(self$1, method, fn, thisArg, wrappedRetFn, args) {
 	let wrappedFn = fn;
 	if (arr !== self$1) {
 		if (needsWrap) wrappedFn = function(item, index) {
-			return fn.call(this, toReactive(item), index, self$1);
+			return fn.call(this, toWrapped(self$1, item), index, self$1);
 		};
 		else if (fn.length > 2) wrappedFn = function(item, index) {
 			return fn.call(this, item, index, self$1);
@@ -829,7 +840,7 @@ function reduce(self$1, method, fn, args) {
 	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);
+			return fn.call(this, acc, toWrapped(self$1, item), index, self$1);
 		};
 		else if (fn.length > 3) wrappedFn = function(acc, item, index) {
 			return fn.call(this, acc, item, index, self$1);
@@ -902,13 +913,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);
 			}
-			if (!isArray(target) && isRef(oldValue) && !isRef(value)) if (isOldValueReadonly) {
+			if (!isArrayWithIntegerKey && isRef(oldValue) && !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,7 +928,7 @@ var MutableReactiveHandler = class extends BaseReactiveHandler {
 				return true;
 			}
 		}
-		const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key);
+		const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn$1(target, key);
 		const result = Reflect.set(target, key, value, isRef(target) ? target : receiver);
 		if (target === toRaw(receiver)) {
 			if (!hadKey) trigger(target, "add", key, value);
@@ -1288,16 +1300,31 @@ var ObjectRefImpl = class {
 		this._defaultValue = _defaultValue;
 		this["__v_isRef"] = true;
 		this._value = void 0;
+		this._raw = toRaw(_object);
+		let shallow = true;
+		let obj = _object;
+		if (!isArray(_object) || !isIntegerKey(String(_key))) do
+			shallow = !isProxy(obj) || 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 && isRef(this._raw[this._key])) {
+			const nestedRef = this._object[this._key];
+			if (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 {
@@ -1318,8 +1345,7 @@ function toRef$1(source, key, defaultValue) {
 	else return 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) {
@@ -1548,7 +1574,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.25/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js
+/**
+* @vue/runtime-core v3.5.25
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
 const stack = [];
 function pushWarningContext(vnode) {
 	stack.push(vnode);
@@ -2102,7 +2133,6 @@ function invokeDirectiveHook(vnode, prevVNode, instance, name) {
 const TeleportEndKey = Symbol("_vte");
 const isTeleport = (type) => type.__isTeleport;
 const leaveCbKey = Symbol("_leaveCb");
-const enterCbKey$1 = Symbol("_enterCb");
 function setTransitionHooks(vnode, hooks) {
 	if (vnode.shapeFlag & 6 && vnode.component) {
 		vnode.transition = hooks;
@@ -2279,10 +2309,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);
@@ -2391,7 +2418,6 @@ const PublicInstanceProxyHandlers = {
 		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,10 +2429,10 @@ 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$1(data, key)) {
 				accessCache[key] = 2;
 				return data[key];
-			} else if ((normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key)) {
+			} else if (hasOwn$1(props, key)) {
 				accessCache[key] = 3;
 				return props[key];
 			} else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
@@ -2440,7 +2466,7 @@ const PublicInstanceProxyHandlers = {
 		} else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn$1(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$1(data, key)) {
 			data[key] = value;
 			return true;
 		} else if (hasOwn$1(instance.props, key)) {
@@ -2458,9 +2484,9 @@ 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$1(data, key) || hasSetupBinding(setupState, key) || hasOwn$1(props, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap, key) || hasOwn$1(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
 	},
 	defineProperty(target, key, descriptor) {
 		if (descriptor.get != null) target._.accessCache[key] = 0;
@@ -2520,11 +2546,6 @@ 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));
-}
 function createDuplicateChecker() {
 	const cache = /* @__PURE__ */ Object.create(null);
 	return (type, key) => {
@@ -2582,12 +2603,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,
@@ -2906,9 +2926,10 @@ 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 {
+	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);
@@ -2927,372 +2948,709 @@ function inject(key, defaultValue, treatDefaultAsFactory = false) {
 function hasInjectionContext() {
 	return !!(getCurrentInstance() || currentApp);
 }
-const internalObjectProto = {};
-const createInternalObject = () => Object.create(internalObjectProto);
-const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
-function initProps(instance, rawProps, isStateful, isSSR = false) {
-	const props = {};
-	const attrs = createInternalObject();
-	instance.propsDefaults = /* @__PURE__ */ Object.create(null);
-	setFullProps(instance, rawProps, props, attrs);
-	for (const key in instance.propsOptions[0]) if (!(key in props)) props[key] = void 0;
-	if (!!(process.env.NODE_ENV !== "production")) validateProps(rawProps || {}, props, instance);
-	if (isStateful) instance.props = isSSR ? props : shallowReactive(props);
-	else if (!instance.type.props) instance.props = attrs;
-	else instance.props = props;
-	instance.attrs = attrs;
-}
-function isInHmrContext(instance) {
-	while (instance) {
-		if (instance.type.__hmrId) return true;
-		instance = instance.parent;
+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 updateProps(instance, rawProps, rawPrevProps, optimized) {
-	const { props, attrs, vnode: { patchFlag } } = instance;
-	const rawCurrentProps = toRaw(props);
-	const [options] = instance.propsOptions;
-	let hasAttrsChanged = false;
-	if (!(!!(process.env.NODE_ENV !== "production") && isInHmrContext(instance)) && (optimized || patchFlag > 0) && !(patchFlag & 16)) {
-		if (patchFlag & 8) {
-			const propsToUpdate = instance.vnode.dynamicProps;
-			for (let i = 0; i < propsToUpdate.length; i++) {
-				let key = propsToUpdate[i];
-				if (isEmitListener(instance.emitsOptions, key)) continue;
-				const value = rawProps[key];
-				if (options) if (hasOwn$1(attrs, key)) {
-					if (value !== attrs[key]) {
-						attrs[key] = value;
-						hasAttrsChanged = true;
-					}
-				} else {
-					const camelizedKey = camelize$1(key);
-					props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false);
-				}
-				else if (value !== attrs[key]) {
-					attrs[key] = value;
-					hasAttrsChanged = true;
-				}
-			}
+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;
 		}
-	} 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) {
-			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) {
-				delete attrs[key];
-				hasAttrsChanged = true;
+	}
+	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();
 	}
-	if (hasAttrsChanged) trigger(instance.attrs, "set", "");
-	if (!!(process.env.NODE_ENV !== "production")) validateProps(rawProps || {}, props, instance);
+	return watchHandle;
 }
-function setFullProps(instance, rawProps, props, attrs) {
-	const [options, needCastKeys] = instance.propsOptions;
-	let hasAttrsChanged = false;
-	let rawCastValues;
-	if (rawProps) for (let key in rawProps) {
-		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;
-		else (rawCastValues || (rawCastValues = {}))[camelKey] = value;
-		else if (!isEmitListener(instance.emitsOptions, key)) {
-			if (!(key in attrs) || value !== attrs[key]) {
-				attrs[key] = value;
-				hasAttrsChanged = true;
+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 getModelModifiers = (props, modelName) => {
+	return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize$1(modelName)}Modifiers`] || props[`${hyphenate$1(modelName)}Modifiers`];
+};
+function emit(instance, event, ...rawArgs) {
+	if (instance.isUnmounted) return;
+	const props = instance.vnode.props || EMPTY_OBJ;
+	if (!!(process.env.NODE_ENV !== "production")) {
+		const { emitsOptions, propsOptions: [propsOptions] } = instance;
+		if (emitsOptions) if (!(event in emitsOptions) && true) {
+			if (!propsOptions || !(toHandlerKey(camelize$1(event)) in propsOptions)) warn$1(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(camelize$1(event))}" prop.`);
+		} else {
+			const validator = emitsOptions[event];
+			if (isFunction(validator)) {
+				if (!validator(...rawArgs)) warn$1(`Invalid event arguments: event validation failed for event "${event}".`);
 			}
 		}
 	}
-	if (needCastKeys) {
-		const rawCurrentProps = toRaw(props);
-		const castValues = rawCastValues || EMPTY_OBJ;
-		for (let i = 0; i < needCastKeys.length; i++) {
-			const key = needCastKeys[i];
-			props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn$1(castValues, key));
-		}
+	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);
 	}
-	return hasAttrsChanged;
-}
-function resolvePropValue(options, props, key, value, instance, isAbsent) {
-	const opt = options[key];
-	if (opt != null) {
-		const hasDefault = hasOwn$1(opt, "default");
-		if (hasDefault && value === void 0) {
-			const defaultValue = opt.default;
-			if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
-				const { propsDefaults } = instance;
-				if (key in propsDefaults) value = propsDefaults[key];
-				else {
-					const reset = setCurrentInstance(instance);
-					value = propsDefaults[key] = defaultValue.call(null, props);
-					reset();
-				}
-			} else value = defaultValue;
-			if (instance.ce) instance.ce._setProp(key, value);
-		}
-		if (opt[0]) {
-			if (isAbsent && !hasDefault) value = false;
-			else if (opt[1] && (value === "" || value === hyphenate$1(key))) value = true;
-		}
+	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);
 	}
-	return value;
 }
-const mixinPropsCache = /* @__PURE__ */ new WeakMap();
-function normalizePropsOptions(comp, appContext, asMixin = false) {
-	const cache = __VUE_OPTIONS_API__ && asMixin ? mixinPropsCache : appContext.propsCache;
+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) return cached;
-	const raw = comp.props;
-	const normalized = {};
-	const needCastKeys = [];
+	if (cached !== void 0) return cached;
+	const raw = comp.emits;
+	let normalized = {};
 	let hasExtends = false;
 	if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
-		const extendProps = (raw2) => {
-			hasExtends = true;
-			const [props, keys] = normalizePropsOptions(raw2, appContext, true);
-			extend(normalized, props);
-			if (keys) needCastKeys.push(...keys);
+		const extendEmits = (raw2) => {
+			const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+			if (normalizedFromExtend) {
+				hasExtends = true;
+				extend(normalized, normalizedFromExtend);
+			}
 		};
-		if (!asMixin && appContext.mixins.length) appContext.mixins.forEach(extendProps);
-		if (comp.extends) extendProps(comp.extends);
-		if (comp.mixins) comp.mixins.forEach(extendProps);
+		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, EMPTY_ARR);
-		return EMPTY_ARR;
+		if (isObject$1(comp)) cache.set(comp, null);
+		return null;
 	}
-	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]);
-		if (validatePropName(normalizedKey)) normalized[normalizedKey] = EMPTY_OBJ;
+	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);
 	}
-	else if (raw) {
-		if (!!(process.env.NODE_ENV !== "production") && !isObject$1(raw)) warn$1(`invalid props options`, raw);
-		for (const key in raw) {
-			const normalizedKey = camelize$1(key);
-			if (validatePropName(normalizedKey)) {
-				const opt = raw[key];
-				const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
-				const propType = prop.type;
-				let shouldCast = false;
-				let shouldCastTrue = true;
-				if (isArray(propType)) for (let index = 0; index < propType.length; ++index) {
-					const type = propType[index];
-					const typeName = isFunction(type) && type.name;
-					if (typeName === "Boolean") {
-						shouldCast = true;
-						break;
-					} else if (typeName === "String") shouldCastTrue = false;
+	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);
 				}
-				else shouldCast = isFunction(propType) && propType.name === "Boolean";
-				prop[0] = shouldCast;
-				prop[1] = shouldCastTrue;
-				if (shouldCast || hasOwn$1(prop, "default")) needCastKeys.push(normalizedKey);
+				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.`);
 			}
 		}
 	}
-	const res = [normalized, needCastKeys];
-	if (isObject$1(comp)) cache.set(comp, res);
-	return res;
-}
-function validatePropName(key) {
-	if (key[0] !== "$" && !isReservedProp(key)) return true;
-	else if (!!(process.env.NODE_ENV !== "production")) warn$1(`Invalid prop name: "${key}" is a reserved property.`);
-	return false;
-}
-function getType(ctor) {
-	if (ctor === null) return "null";
-	if (typeof ctor === "function") return ctor.name || "";
-	else if (typeof ctor === "object") return ctor.constructor && ctor.constructor.name || "";
-	return "";
-}
-function validateProps(rawProps, props, instance) {
-	const resolvedValues = toRaw(props);
-	const options = instance.propsOptions[0];
-	const camelizePropsKey = Object.keys(rawProps).map((key) => camelize$1(key));
-	for (const key in options) {
-		let opt = options[key];
-		if (opt == null) continue;
-		validateProp(key, resolvedValues[key], opt, !!(process.env.NODE_ENV !== "production") ? shallowReadonly(resolvedValues) : resolvedValues, !camelizePropsKey.includes(key));
+	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;
 }
-function validateProp(name, value, prop, props, isAbsent) {
-	const { type, required, validator, skipCheck } = prop;
-	if (required && isAbsent) {
-		warn$1("Missing required prop: \"" + name + "\"");
-		return;
+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;
 	}
-	if (value == null && !required) return;
-	if (type != null && type !== true && !skipCheck) {
-		let isValid = false;
-		const types = isArray(type) ? type : [type];
-		const expectedTypes = [];
-		for (let i = 0; i < types.length && !isValid; i++) {
-			const { valid, expectedType } = assertType(value, types[i]);
-			expectedTypes.push(expectedType || "");
-			isValid = valid;
+	return singleRoot;
+}
+const getFunctionalFallthrough = (attrs) => {
+	let res;
+	for (const key in attrs) if (key === "class" || key === "style" || isOn(key)) (res || (res = {}))[key] = attrs[key];
+	return res;
+};
+const filterModelListeners = (attrs, props) => {
+	const res = {};
+	for (const key in attrs) if (!isModelListener(key) || !(key.slice(9) in props)) res[key] = attrs[key];
+	return res;
+};
+const isElementRoot = (vnode) => {
+	return vnode.shapeFlag & 7 || vnode.type === Comment;
+};
+function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+	const { props: prevProps, children: prevChildren, component } = prevVNode;
+	const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+	const emits = component.emitsOptions;
+	if (!!(process.env.NODE_ENV !== "production") && (prevChildren || nextChildren) && isHmrUpdating) return true;
+	if (nextVNode.dirs || nextVNode.transition) return true;
+	if (optimized && patchFlag >= 0) {
+		if (patchFlag & 1024) return true;
+		if (patchFlag & 16) {
+			if (!prevProps) return !!nextProps;
+			return hasPropsChanged(prevProps, nextProps, emits);
+		} else if (patchFlag & 8) {
+			const dynamicProps = nextVNode.dynamicProps;
+			for (let i = 0; i < dynamicProps.length; i++) {
+				const key = dynamicProps[i];
+				if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) return true;
+			}
 		}
-		if (!isValid) {
-			warn$1(getInvalidTypeMessage(name, value, expectedTypes));
-			return;
+	} 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);
 	}
-	if (validator && !validator(value, props)) warn$1("Invalid prop: custom validator check failed for prop \"" + name + "\".");
-}
-const isSimpleType = /* @__PURE__ */ makeMap("String,Number,Boolean,Function,Symbol,BigInt");
-function assertType(value, type) {
-	let valid;
-	const expectedType = getType(type);
-	if (expectedType === "null") valid = value === null;
-	else if (isSimpleType(expectedType)) {
-		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 === "Array") valid = isArray(value);
-	else valid = value instanceof type;
-	return {
-		valid,
-		expectedType
-	};
+	return false;
 }
-function getInvalidTypeMessage(name, value, expectedTypes) {
-	if (expectedTypes.length === 0) return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
-	let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
-	const expectedType = expectedTypes[0];
-	const receivedType = toRawType(value);
-	const expectedValue = styleValue(value, expectedType);
-	const receivedValue = styleValue(value, receivedType);
-	if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) message += ` with value ${expectedValue}`;
-	message += `, got ${receivedType} `;
-	if (isExplicable(receivedType)) message += `with value ${receivedValue}.`;
-	return message;
+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 styleValue(value, type) {
-	if (type === "String") return `"${value}"`;
-	else if (type === "Number") return `${Number(value)}`;
-	else return `${value}`;
+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 isExplicable(type) {
-	return [
-		"string",
-		"number",
-		"boolean"
-	].some((elem) => type.toLowerCase() === elem);
+const internalObjectProto = {};
+const createInternalObject = () => Object.create(internalObjectProto);
+const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
+function initProps(instance, rawProps, isStateful, isSSR = false) {
+	const props = {};
+	const attrs = createInternalObject();
+	instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+	setFullProps(instance, rawProps, props, attrs);
+	for (const key in instance.propsOptions[0]) if (!(key in props)) props[key] = void 0;
+	if (!!(process.env.NODE_ENV !== "production")) validateProps(rawProps || {}, props, instance);
+	if (isStateful) instance.props = isSSR ? props : shallowReactive(props);
+	else if (!instance.type.props) instance.props = attrs;
+	else instance.props = props;
+	instance.attrs = attrs;
 }
-function isBoolean(...args) {
-	return args.some((elem) => elem.toLowerCase() === "boolean");
+function isInHmrContext(instance) {
+	while (instance) {
+		if (instance.type.__hmrId) return true;
+		instance = instance.parent;
+	}
 }
-const isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
-const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
-const normalizeSlot = (key, rawSlot, ctx) => {
-	if (rawSlot._n) return rawSlot;
-	const normalized = withCtx((...args) => {
-		if (!!(process.env.NODE_ENV !== "production") && currentInstance && !(ctx === null && currentRenderingInstance) && !(ctx && ctx.root !== currentInstance.root)) warn$1(`Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`);
-		return normalizeSlotValue(rawSlot(...args));
-	}, ctx);
-	normalized._c = false;
-	return normalized;
-};
-const normalizeObjectSlots = (rawSlots, slots, instance) => {
-	const ctx = rawSlots._ctx;
-	for (const key in rawSlots) {
-		if (isInternalKey(key)) continue;
-		const value = rawSlots[key];
-		if (isFunction(value)) slots[key] = normalizeSlot(key, value, ctx);
-		else if (value != null) {
-			if (!!(process.env.NODE_ENV !== "production") && true) warn$1(`Non-function value encountered for slot "${key}". Prefer function slots for better performance.`);
-			const normalized = normalizeSlotValue(value);
-			slots[key] = () => normalized;
+function updateProps(instance, rawProps, rawPrevProps, optimized) {
+	const { props, attrs, vnode: { patchFlag } } = instance;
+	const rawCurrentProps = toRaw(props);
+	const [options] = instance.propsOptions;
+	let hasAttrsChanged = false;
+	if (!(!!(process.env.NODE_ENV !== "production") && isInHmrContext(instance)) && (optimized || patchFlag > 0) && !(patchFlag & 16)) {
+		if (patchFlag & 8) {
+			const propsToUpdate = instance.vnode.dynamicProps;
+			for (let i = 0; i < propsToUpdate.length; i++) {
+				let key = propsToUpdate[i];
+				if (isEmitListener(instance.emitsOptions, key)) continue;
+				const value = rawProps[key];
+				if (options) if (hasOwn$1(attrs, key)) {
+					if (value !== attrs[key]) {
+						attrs[key] = value;
+						hasAttrsChanged = true;
+					}
+				} else {
+					const camelizedKey = camelize$1(key);
+					props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false);
+				}
+				else if (value !== attrs[key]) {
+					attrs[key] = value;
+					hasAttrsChanged = true;
+				}
+			}
+		}
+	} 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) {
+			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) {
+				delete attrs[key];
+				hasAttrsChanged = true;
+			}
 		}
 	}
-};
-const normalizeVNodeSlots = (instance, children) => {
-	if (!!(process.env.NODE_ENV !== "production") && !isKeepAlive(instance.vnode) && true) warn$1(`Non-function value encountered for default slot. Prefer function slots for better performance.`);
-	const normalized = normalizeSlotValue(children);
-	instance.slots.default = () => normalized;
-};
-const assignSlots = (slots, children, optimized) => {
-	for (const key in children) if (optimized || !isInternalKey(key)) slots[key] = children[key];
-};
-const initSlots = (instance, children, optimized) => {
-	const slots = instance.slots = createInternalObject();
-	if (instance.vnode.shapeFlag & 32) {
-		const type = children._;
-		if (type) {
-			assignSlots(slots, children, optimized);
-			if (optimized) def(slots, "_", type, true);
-		} else normalizeObjectSlots(children, slots);
-	} else if (children) normalizeVNodeSlots(instance, children);
-};
-const updateSlots = (instance, children, optimized) => {
-	const { vnode, slots } = instance;
-	let needDeletionCheck = true;
-	let deletionComparisonTarget = EMPTY_OBJ;
-	if (vnode.shapeFlag & 32) {
-		const type = children._;
-		if (type) if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating) {
-			assignSlots(slots, children, optimized);
-			trigger(instance, "set", "$slots");
-		} else if (optimized && type === 1) needDeletionCheck = false;
-		else assignSlots(slots, children, optimized);
-		else {
-			needDeletionCheck = !children.$stable;
-			normalizeObjectSlots(children, slots);
+	if (hasAttrsChanged) trigger(instance.attrs, "set", "");
+	if (!!(process.env.NODE_ENV !== "production")) validateProps(rawProps || {}, props, instance);
+}
+function setFullProps(instance, rawProps, props, attrs) {
+	const [options, needCastKeys] = instance.propsOptions;
+	let hasAttrsChanged = false;
+	let rawCastValues;
+	if (rawProps) for (let key in rawProps) {
+		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;
+		else (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+		else if (!isEmitListener(instance.emitsOptions, key)) {
+			if (!(key in attrs) || value !== attrs[key]) {
+				attrs[key] = value;
+				hasAttrsChanged = true;
+			}
 		}
-		deletionComparisonTarget = children;
-	} else if (children) {
-		normalizeVNodeSlots(instance, children);
-		deletionComparisonTarget = { default: 1 };
 	}
-	if (needDeletionCheck) {
-		for (const key in slots) if (!isInternalKey(key) && deletionComparisonTarget[key] == null) delete slots[key];
+	if (needCastKeys) {
+		const rawCurrentProps = toRaw(props);
+		const castValues = rawCastValues || EMPTY_OBJ;
+		for (let i = 0; i < needCastKeys.length; i++) {
+			const key = needCastKeys[i];
+			props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn$1(castValues, key));
+		}
 	}
-};
-let supported;
-let perf;
-function startMeasure(instance, type) {
-	if (instance.appContext.config.performance && isSupported()) perf.mark(`vue-${type}-${instance.uid}`);
-	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+	return hasAttrsChanged;
 }
-function endMeasure(instance, type) {
-	if (instance.appContext.config.performance && isSupported()) {
-		const startTag = `vue-${type}-${instance.uid}`;
-		const endTag = startTag + `:end`;
-		const measureName = `<${formatComponentName(instance, instance.type)}> ${type}`;
-		perf.mark(endTag);
-		perf.measure(measureName, startTag, endTag);
-		perf.clearMeasures(measureName);
-		perf.clearMarks(startTag);
-		perf.clearMarks(endTag);
+function resolvePropValue(options, props, key, value, instance, isAbsent) {
+	const opt = options[key];
+	if (opt != null) {
+		const hasDefault = hasOwn$1(opt, "default");
+		if (hasDefault && value === void 0) {
+			const defaultValue = opt.default;
+			if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
+				const { propsDefaults } = instance;
+				if (key in propsDefaults) value = propsDefaults[key];
+				else {
+					const reset = setCurrentInstance(instance);
+					value = propsDefaults[key] = defaultValue.call(null, props);
+					reset();
+				}
+			} else value = defaultValue;
+			if (instance.ce) instance.ce._setProp(key, value);
+		}
+		if (opt[0]) {
+			if (isAbsent && !hasDefault) value = false;
+			else if (opt[1] && (value === "" || value === hyphenate$1(key))) value = true;
+		}
 	}
-	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
-}
-function isSupported() {
-	if (supported !== void 0) return supported;
-	if (typeof window !== "undefined" && window.performance) {
-		supported = true;
-		perf = window.performance;
-	} else supported = false;
-	return supported;
+	return value;
 }
-function initFeatureFlags() {
-	const needWarn = [];
-	if (typeof __VUE_OPTIONS_API__ !== "boolean") {
-		process.env.NODE_ENV !== "production" && needWarn.push(`__VUE_OPTIONS_API__`);
-		getGlobalThis().__VUE_OPTIONS_API__ = true;
+const mixinPropsCache = /* @__PURE__ */ new WeakMap();
+function normalizePropsOptions(comp, appContext, asMixin = false) {
+	const cache = __VUE_OPTIONS_API__ && asMixin ? mixinPropsCache : appContext.propsCache;
+	const cached = cache.get(comp);
+	if (cached) return cached;
+	const raw = comp.props;
+	const normalized = {};
+	const needCastKeys = [];
+	let hasExtends = false;
+	if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
+		const extendProps = (raw2) => {
+			hasExtends = true;
+			const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+			extend(normalized, props);
+			if (keys) needCastKeys.push(...keys);
+		};
+		if (!asMixin && appContext.mixins.length) appContext.mixins.forEach(extendProps);
+		if (comp.extends) extendProps(comp.extends);
+		if (comp.mixins) comp.mixins.forEach(extendProps);
 	}
-	if (typeof __VUE_PROD_DEVTOOLS__ !== "boolean") {
-		process.env.NODE_ENV !== "production" && needWarn.push(`__VUE_PROD_DEVTOOLS__`);
-		getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;
+	if (!raw && !hasExtends) {
+		if (isObject$1(comp)) cache.set(comp, EMPTY_ARR);
+		return EMPTY_ARR;
 	}
-	if (typeof __VUE_PROD_HYDRATION_MISMATCH_DETAILS__ !== "boolean") {
-		process.env.NODE_ENV !== "production" && needWarn.push(`__VUE_PROD_HYDRATION_MISMATCH_DETAILS__`);
+	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]);
+		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);
+		for (const key in raw) {
+			const normalizedKey = camelize$1(key);
+			if (validatePropName(normalizedKey)) {
+				const opt = raw[key];
+				const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
+				const propType = prop.type;
+				let shouldCast = false;
+				let shouldCastTrue = true;
+				if (isArray(propType)) for (let index = 0; index < propType.length; ++index) {
+					const type = propType[index];
+					const typeName = isFunction(type) && type.name;
+					if (typeName === "Boolean") {
+						shouldCast = true;
+						break;
+					} else if (typeName === "String") shouldCastTrue = false;
+				}
+				else shouldCast = isFunction(propType) && propType.name === "Boolean";
+				prop[0] = shouldCast;
+				prop[1] = shouldCastTrue;
+				if (shouldCast || hasOwn$1(prop, "default")) needCastKeys.push(normalizedKey);
+			}
+		}
+	}
+	const res = [normalized, needCastKeys];
+	if (isObject$1(comp)) cache.set(comp, res);
+	return res;
+}
+function validatePropName(key) {
+	if (key[0] !== "$" && !isReservedProp(key)) return true;
+	else if (!!(process.env.NODE_ENV !== "production")) warn$1(`Invalid prop name: "${key}" is a reserved property.`);
+	return false;
+}
+function getType(ctor) {
+	if (ctor === null) return "null";
+	if (typeof ctor === "function") return ctor.name || "";
+	else if (typeof ctor === "object") return ctor.constructor && ctor.constructor.name || "";
+	return "";
+}
+function validateProps(rawProps, props, instance) {
+	const resolvedValues = toRaw(props);
+	const options = instance.propsOptions[0];
+	const camelizePropsKey = Object.keys(rawProps).map((key) => camelize$1(key));
+	for (const key in options) {
+		let opt = options[key];
+		if (opt == null) continue;
+		validateProp(key, resolvedValues[key], opt, !!(process.env.NODE_ENV !== "production") ? shallowReadonly(resolvedValues) : resolvedValues, !camelizePropsKey.includes(key));
+	}
+}
+function validateProp(name, value, prop, props, isAbsent) {
+	const { type, required, validator, skipCheck } = prop;
+	if (required && isAbsent) {
+		warn$1("Missing required prop: \"" + name + "\"");
+		return;
+	}
+	if (value == null && !required) return;
+	if (type != null && type !== true && !skipCheck) {
+		let isValid = false;
+		const types = isArray(type) ? type : [type];
+		const expectedTypes = [];
+		for (let i = 0; i < types.length && !isValid; i++) {
+			const { valid, expectedType } = assertType(value, types[i]);
+			expectedTypes.push(expectedType || "");
+			isValid = valid;
+		}
+		if (!isValid) {
+			warn$1(getInvalidTypeMessage(name, value, expectedTypes));
+			return;
+		}
+	}
+	if (validator && !validator(value, props)) warn$1("Invalid prop: custom validator check failed for prop \"" + name + "\".");
+}
+const isSimpleType = /* @__PURE__ */ makeMap("String,Number,Boolean,Function,Symbol,BigInt");
+function assertType(value, type) {
+	let valid;
+	const expectedType = getType(type);
+	if (expectedType === "null") valid = value === null;
+	else if (isSimpleType(expectedType)) {
+		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 === "Array") valid = isArray(value);
+	else valid = value instanceof type;
+	return {
+		valid,
+		expectedType
+	};
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+	if (expectedTypes.length === 0) return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
+	let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
+	const expectedType = expectedTypes[0];
+	const receivedType = toRawType(value);
+	const expectedValue = styleValue(value, expectedType);
+	const receivedValue = styleValue(value, receivedType);
+	if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) message += ` with value ${expectedValue}`;
+	message += `, got ${receivedType} `;
+	if (isExplicable(receivedType)) message += `with value ${receivedValue}.`;
+	return message;
+}
+function styleValue(value, type) {
+	if (type === "String") return `"${value}"`;
+	else if (type === "Number") return `${Number(value)}`;
+	else return `${value}`;
+}
+function isExplicable(type) {
+	return [
+		"string",
+		"number",
+		"boolean"
+	].some((elem) => type.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+	return args.some((elem) => elem.toLowerCase() === "boolean");
+}
+const isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
+const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+const normalizeSlot = (key, rawSlot, ctx) => {
+	if (rawSlot._n) return rawSlot;
+	const normalized = withCtx((...args) => {
+		if (!!(process.env.NODE_ENV !== "production") && currentInstance && !(ctx === null && currentRenderingInstance) && !(ctx && ctx.root !== currentInstance.root)) warn$1(`Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`);
+		return normalizeSlotValue(rawSlot(...args));
+	}, ctx);
+	normalized._c = false;
+	return normalized;
+};
+const normalizeObjectSlots = (rawSlots, slots, instance) => {
+	const ctx = rawSlots._ctx;
+	for (const key in rawSlots) {
+		if (isInternalKey(key)) continue;
+		const value = rawSlots[key];
+		if (isFunction(value)) slots[key] = normalizeSlot(key, value, ctx);
+		else if (value != null) {
+			if (!!(process.env.NODE_ENV !== "production") && true) warn$1(`Non-function value encountered for slot "${key}". Prefer function slots for better performance.`);
+			const normalized = normalizeSlotValue(value);
+			slots[key] = () => normalized;
+		}
+	}
+};
+const normalizeVNodeSlots = (instance, children) => {
+	if (!!(process.env.NODE_ENV !== "production") && !isKeepAlive(instance.vnode) && true) warn$1(`Non-function value encountered for default slot. Prefer function slots for better performance.`);
+	const normalized = normalizeSlotValue(children);
+	instance.slots.default = () => normalized;
+};
+const assignSlots = (slots, children, optimized) => {
+	for (const key in children) if (optimized || !isInternalKey(key)) slots[key] = children[key];
+};
+const initSlots = (instance, children, optimized) => {
+	const slots = instance.slots = createInternalObject();
+	if (instance.vnode.shapeFlag & 32) {
+		const type = children._;
+		if (type) {
+			assignSlots(slots, children, optimized);
+			if (optimized) def(slots, "_", type, true);
+		} else normalizeObjectSlots(children, slots);
+	} else if (children) normalizeVNodeSlots(instance, children);
+};
+const updateSlots = (instance, children, optimized) => {
+	const { vnode, slots } = instance;
+	let needDeletionCheck = true;
+	let deletionComparisonTarget = EMPTY_OBJ;
+	if (vnode.shapeFlag & 32) {
+		const type = children._;
+		if (type) if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating) {
+			assignSlots(slots, children, optimized);
+			trigger(instance, "set", "$slots");
+		} else if (optimized && type === 1) needDeletionCheck = false;
+		else assignSlots(slots, children, optimized);
+		else {
+			needDeletionCheck = !children.$stable;
+			normalizeObjectSlots(children, slots);
+		}
+		deletionComparisonTarget = children;
+	} else if (children) {
+		normalizeVNodeSlots(instance, children);
+		deletionComparisonTarget = { default: 1 };
+	}
+	if (needDeletionCheck) {
+		for (const key in slots) if (!isInternalKey(key) && deletionComparisonTarget[key] == null) delete slots[key];
+	}
+};
+let supported;
+let perf;
+function startMeasure(instance, type) {
+	if (instance.appContext.config.performance && isSupported()) perf.mark(`vue-${type}-${instance.uid}`);
+	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+}
+function endMeasure(instance, type) {
+	if (instance.appContext.config.performance && isSupported()) {
+		const startTag = `vue-${type}-${instance.uid}`;
+		const endTag = startTag + `:end`;
+		const measureName = `<${formatComponentName(instance, instance.type)}> ${type}`;
+		perf.mark(endTag);
+		perf.measure(measureName, startTag, endTag);
+		perf.clearMeasures(measureName);
+		perf.clearMarks(startTag);
+		perf.clearMarks(endTag);
+	}
+	if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+}
+function isSupported() {
+	if (supported !== void 0) return supported;
+	if (typeof window !== "undefined" && window.performance) {
+		supported = true;
+		perf = window.performance;
+	} else supported = false;
+	return supported;
+}
+function initFeatureFlags() {
+	const needWarn = [];
+	if (typeof __VUE_OPTIONS_API__ !== "boolean") {
+		process.env.NODE_ENV !== "production" && needWarn.push(`__VUE_OPTIONS_API__`);
+		getGlobalThis().__VUE_OPTIONS_API__ = true;
+	}
+	if (typeof __VUE_PROD_DEVTOOLS__ !== "boolean") {
+		process.env.NODE_ENV !== "production" && needWarn.push(`__VUE_PROD_DEVTOOLS__`);
+		getGlobalThis().__VUE_PROD_DEVTOOLS__ = false;
+	}
+	if (typeof __VUE_PROD_HYDRATION_MISMATCH_DETAILS__ !== "boolean") {
+		process.env.NODE_ENV !== "production" && needWarn.push(`__VUE_PROD_HYDRATION_MISMATCH_DETAILS__`);
 		getGlobalThis().__VUE_PROD_HYDRATION_MISMATCH_DETAILS__ = false;
 	}
 	if (!!(process.env.NODE_ENV !== "production") && needWarn.length) {
@@ -3393,7 +3751,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 +3802,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 +3856,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) => {
@@ -3948,514 +4310,118 @@ function baseCreateRenderer(options, createHydrationFns) {
 		if (vnode.shapeFlag & 6) return getNextHostNode(vnode.component.subTree);
 		if (vnode.shapeFlag & 128) return vnode.suspense.next();
 		const el = hostNextSibling(vnode.anchor || vnode.el);
-		const teleportEnd = el && el[TeleportEndKey];
-		return teleportEnd ? hostNextSibling(teleportEnd) : el;
-	};
-	let isFlushing = false;
-	const render$1 = (vnode, container, namespace) => {
-		if (vnode == null) {
-			if (container._vnode) unmount(container._vnode, null, null, true);
-		} else patch(container._vnode || null, vnode, container, null, null, null, namespace);
-		container._vnode = vnode;
-		if (!isFlushing) {
-			isFlushing = true;
-			flushPreFlushCbs();
-			flushPostFlushCbs();
-			isFlushing = false;
-		}
-	};
-	const internals = {
-		p: patch,
-		um: unmount,
-		m: move,
-		r: remove$1,
-		mt: mountComponent,
-		mc: mountChildren,
-		pc: patchChildren,
-		pbc: patchBlockChildren,
-		n: getNextHostNode,
-		o: options
-	};
-	let hydrate;
-	let hydrateNode;
-	if (createHydrationFns) [hydrate, hydrateNode] = createHydrationFns(internals);
-	return {
-		render: render$1,
-		hydrate,
-		createApp: createAppAPI(render$1, 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) {
-	if (allowed) {
-		effect$1.flags |= 32;
-		job.flags |= 4;
-	} else {
-		effect$1.flags &= -33;
-		job.flags &= -5;
-	}
-}
-function needTransition(parentSuspense, transition) {
-	return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
-}
-function traverseStaticChildren(n1, n2, shallow = false) {
-	const ch1 = n1.children;
-	const ch2 = n2.children;
-	if (isArray(ch1) && isArray(ch2)) for (let i = 0; i < ch1.length; i++) {
-		const c1 = ch1[i];
-		let c2 = ch2[i];
-		if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
-			if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
-				c2 = ch2[i] = cloneIfMounted(ch2[i]);
-				c2.el = c1.el;
-			}
-			if (!shallow && c2.patchFlag !== -2) traverseStaticChildren(c1, c2);
-		}
-		if (c2.type === Text && c2.patchFlag !== -1) c2.el = c1.el;
-		if (c2.type === Comment && !c2.el) c2.el = c1.el;
-		if (!!(process.env.NODE_ENV !== "production")) c2.el && (c2.el.__vnode = c2);
-	}
-}
-function getSequence(arr) {
-	const p$1 = arr.slice();
-	const result = [0];
-	let i, j, u, v, c;
-	const len = arr.length;
-	for (i = 0; i < len; i++) {
-		const arrI = arr[i];
-		if (arrI !== 0) {
-			j = result[result.length - 1];
-			if (arr[j] < arrI) {
-				p$1[i] = j;
-				result.push(i);
-				continue;
-			}
-			u = 0;
-			v = result.length - 1;
-			while (u < v) {
-				c = u + v >> 1;
-				if (arr[result[c]] < arrI) u = c + 1;
-				else v = c;
-			}
-			if (arrI < arr[result[u]]) {
-				if (u > 0) p$1[i] = result[u - 1];
-				result[u] = i;
-			}
-		}
-	}
-	u = result.length;
-	v = result[u - 1];
-	while (u-- > 0) {
-		result[u] = v;
-		v = p$1[v];
-	}
-	return result;
-}
-function locateNonHydratedAsyncRoot(instance) {
-	const subComponent = instance.subTree.component;
-	if (subComponent) if (subComponent.asyncDep && !subComponent.asyncResolved) return subComponent;
-	else return locateNonHydratedAsyncRoot(subComponent);
-}
-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 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;
-	};
-}
-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`];
-};
-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);
-			}
-		};
-		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);
-				}
-				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];
+		const teleportEnd = el && el[TeleportEndKey];
+		return teleportEnd ? hostNextSibling(teleportEnd) : el;
+	};
+	let isFlushing = false;
+	const render$1 = (vnode, container, namespace) => {
+		if (vnode == null) {
+			if (container._vnode) unmount(container._vnode, null, null, true);
+		} else patch(container._vnode || null, vnode, container, null, null, null, namespace);
+		container._vnode = vnode;
+		if (!isFlushing) {
+			isFlushing = true;
+			flushPreFlushCbs();
+			flushPostFlushCbs();
+			isFlushing = false;
 		}
 	};
-	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;
+	const internals = {
+		p: patch,
+		um: unmount,
+		m: move,
+		r: remove$1,
+		mt: mountComponent,
+		mc: mountChildren,
+		pc: patchChildren,
+		pbc: patchBlockChildren,
+		n: getNextHostNode,
+		o: options
+	};
+	let hydrate;
+	let hydrateNode;
+	if (createHydrationFns) [hydrate, hydrateNode] = createHydrationFns(internals);
+	return {
+		render: render$1,
+		hydrate,
+		createApp: createAppAPI(render$1, 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) {
+	if (allowed) {
+		effect$1.flags |= 32;
+		job.flags |= 4;
+	} else {
+		effect$1.flags &= -33;
+		job.flags &= -5;
 	}
-	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;
+function needTransition(parentSuspense, transition) {
+	return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
+}
+function traverseStaticChildren(n1, n2, shallow = false) {
+	const ch1 = n1.children;
+	const ch2 = n2.children;
+	if (isArray(ch1) && isArray(ch2)) for (let i = 0; i < ch1.length; i++) {
+		const c1 = ch1[i];
+		let c2 = ch2[i];
+		if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
+			if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
+				c2 = ch2[i] = cloneIfMounted(ch2[i]);
+				c2.el = c1.el;
 			}
+			if (!shallow && c2.patchFlag !== -2) traverseStaticChildren(c1, c2);
 		}
-	} 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);
+		if (c2.type === Text && c2.patchFlag !== -1) c2.el = c1.el;
+		if (c2.type === Comment && !c2.el) c2.el = c1.el;
+		if (!!(process.env.NODE_ENV !== "production")) c2.el && (c2.el.__vnode = c2);
 	}
-	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;
+function getSequence(arr) {
+	const p$1 = arr.slice();
+	const result = [0];
+	let i, j, u, v, c;
+	const len = arr.length;
+	for (i = 0; i < len; i++) {
+		const arrI = arr[i];
+		if (arrI !== 0) {
+			j = result[result.length - 1];
+			if (arr[j] < arrI) {
+				p$1[i] = j;
+				result.push(i);
+				continue;
+			}
+			u = 0;
+			v = result.length - 1;
+			while (u < v) {
+				c = u + v >> 1;
+				if (arr[result[c]] < arrI) u = c + 1;
+				else v = c;
+			}
+			if (arrI < arr[result[u]]) {
+				if (u > 0) p$1[i] = result[u - 1];
+				result[u] = i;
+			}
+		}
 	}
-	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;
+	u = result.length;
+	v = result[u - 1];
+	while (u-- > 0) {
+		result[u] = v;
+		v = p$1[v];
 	}
+	return result;
+}
+function locateNonHydratedAsyncRoot(instance) {
+	const subComponent = instance.subTree.component;
+	if (subComponent) if (subComponent.asyncDep && !subComponent.asyncResolved) return subComponent;
+	else return locateNonHydratedAsyncRoot(subComponent);
+}
+function invalidateMount(hooks) {
+	if (hooks) for (let i = 0; i < hooks.length; i++) hooks[i].flags |= 8;
 }
 const isSuspense = (type) => type.__isSuspense;
 function queueEffectWithSuspense(fn, suspense) {
@@ -4640,6 +4606,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 +4806,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 +4841,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);
@@ -5010,11 +4977,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`;
 }
@@ -5191,13 +5158,18 @@ function initCustomFormatter() {
 	if (window.devtoolsFormatters) window.devtoolsFormatters.push(formatter);
 	else window.devtoolsFormatters = [formatter];
 }
-const version = "3.5.22";
+const version = "3.5.25";
 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.25/node_modules/@vue/runtime-dom/dist/runtime-dom.esm-bundler.js
+/**
+* @vue/runtime-dom v3.5.25
+* (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 {
@@ -5413,10 +5385,8 @@ function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
 	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;
 		}
@@ -5488,6 +5458,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 +5504,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;
@@ -5645,7 +5618,7 @@ var VueElement = class VueElement extends BaseClass {
 				return this._getProp(key);
 			},
 			set(val) {
-				this._setProp(key, val, true, true);
+				this._setProp(key, val, true, !this._patching);
 			}
 		});
 	}
@@ -5668,6 +5641,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;
@@ -5785,10 +5759,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 +5775,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 +5802,6 @@ var VueElement = class VueElement extends BaseClass {
 		}
 	}
 };
-const moveCbKey = Symbol("_moveCb");
-const enterCbKey = Symbol("_enterCb");
-const assignKey = Symbol("_assign");
 const systemModifiers = [
 	"ctrl",
 	"shift",
@@ -5923,28 +5910,50 @@ 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.25_typescript@5.9.3/node_modules/vue/dist/vue.runtime.esm-bundler.js
+/**
+* vue v3.5.25
+* (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) {
+//#region ../../node_modules/.pnpm/@vueuse+shared@14.1.0_vue@3.5.25_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js
+/**
+* Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
+*
+* @param fn
+*/
+function tryOnScopeDispose(fn, failSilently) {
 	if (getCurrentScope()) {
-		onScopeDispose(fn);
+		onScopeDispose(fn, failSilently);
 		return true;
 	}
 	return false;
 }
 const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
-const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
-	var _a;
+/**
+* On the basis of `inject`, it is allowed to directly call inject to obtain the value after call provide in the same component.
+*
+* @example
+* ```ts
+* injectLocal('MyInjectionKey', 1)
+* const injectedValue = injectLocal('MyInjectionKey') // injectedValue === 1
+* ```
+*
+* @__NO_SIDE_EFFECTS__
+*/
+const injectLocal = (...args) => {
+	var _getCurrentInstance;
 	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];
+	const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+	const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+	if (owner == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+	if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
 	return inject(...args);
 };
 const isClient = typeof window !== "undefined" && typeof document !== "undefined";
@@ -5961,6 +5970,9 @@ function toRef(...args) {
 		set: noop
 	}))) : ref(r);
 }
+/**
+* @internal
+*/
 function createFilterWrapper(filter, fn) {
 	function wrapper(...args) {
 		return new Promise((resolve, reject) => {
@@ -5973,20 +5985,23 @@ function createFilterWrapper(filter, fn) {
 	}
 	return wrapper;
 }
-const bypassFilter = (invoke) => {
-	return invoke();
+const bypassFilter = (invoke$1) => {
+	return invoke$1();
 };
+/**
+* Create an EventFilter that debounce the events
+*/
 function debounceFilter(ms, options = {}) {
 	let timer;
 	let maxTimer;
 	let lastRejector = noop;
-	const _clearTimeout = (timer2) => {
-		clearTimeout(timer2);
+	const _clearTimeout = (timer$1) => {
+		clearTimeout(timer$1);
 		lastRejector();
 		lastRejector = noop;
 	};
 	let lastInvoker;
-	const filter = (invoke) => {
+	const filter = (invoke$1) => {
 		const duration = toValue(ms);
 		const maxDuration = toValue(options.maxWait);
 		if (timer) _clearTimeout(timer);
@@ -5995,11 +6010,11 @@ function debounceFilter(ms, options = {}) {
 				_clearTimeout(maxTimer);
 				maxTimer = void 0;
 			}
-			return Promise.resolve(invoke());
+			return Promise.resolve(invoke$1());
 		}
 		return new Promise((resolve, reject) => {
 			lastRejector = options.rejectOnCancel ? reject : resolve;
-			lastInvoker = invoke;
+			lastInvoker = invoke$1;
 			if (maxDuration && !maxTimer) maxTimer = setTimeout(() => {
 				if (timer) _clearTimeout(timer);
 				maxTimer = void 0;
@@ -6008,12 +6023,18 @@ function debounceFilter(ms, options = {}) {
 			timer = setTimeout(() => {
 				if (maxTimer) _clearTimeout(maxTimer);
 				maxTimer = void 0;
-				resolve(invoke());
+				resolve(invoke$1());
 			}, duration);
 		});
 	};
 	return filter;
 }
+/**
+* EventFilter that gives extra controls to pause and resume the filter
+*
+* @param extendFilter  Extra filter to apply when the PausableFilter is active, default to none
+* @param options Options to configure the filter
+*/
 function pausableFilter(extendFilter = bypassFilter, options = {}) {
 	const { initialState = "active" } = options;
 	const isActive = toRef(initialState === "active");
@@ -6033,6 +6054,9 @@ function pausableFilter(extendFilter = bypassFilter, options = {}) {
 		eventFilter
 	};
 }
+/**
+* Get a px value for SSR use, do not rely on this method outside of SSR as REM unit is assumed at 16px, which might not be the case on the client
+*/
 function pxValue(px) {
 	return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
 }
@@ -6040,10 +6064,10 @@ function toArray(value) {
 	return Array.isArray(value) ? value : [value];
 }
 function cacheStringFunction(fn) {
-	const cache = /* @__PURE__ */ Object.create(null);
-	return (str) => {
+	const cache = 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());
@@ -6054,16 +6078,27 @@ const camelize = cacheStringFunction((str) => {
 function getLifeCycleTarget(target) {
 	return target || getCurrentInstance();
 }
-/* @__NO_SIDE_EFFECTS__ */
+/**
+* Debounce execution of a function.
+*
+* @see https://vueuse.org/useDebounceFn
+* @param  fn          A function to be executed after delay milliseconds debounced.
+* @param  ms          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+* @param  options     Options
+*
+* @return A new, debounce, function.
+*
+* @__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;
+	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: filter, initialState = "active", ...watchOptions } = options;
 	const { eventFilter, pause, resume, isActive } = pausableFilter(filter, { initialState });
 	return {
 		stop: watchWithFilter(source, cb, {
@@ -6075,37 +6110,25 @@ function watchPausable(source, cb, options = {}) {
 		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;
-}
+/** @deprecated use `watchPausable` instead */
+const pausableWatch = watchPausable;
+/**
+* Call onMounted() if it's inside a component lifecycle, if not, just call the function
+*
+* @param fn
+* @param sync if set to false, it will run in the nextTick() of Vue
+* @param target
+*/
 function tryOnMounted(fn, sync = true, target) {
 	if (getLifeCycleTarget(target)) onMounted(fn, target);
 	else if (sync) fn();
 	else nextTick(fn);
 }
+/**
+* Shorthand for watching value with {immediate: true}
+*
+* @see https://vueuse.org/watchImmediate
+*/
 function watchImmediate(source, cb, options) {
 	return watch(source, cb, {
 		...options,
@@ -6114,22 +6137,22 @@ function watchImmediate(source, cb, options) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/@vueuse+core@13.9.0_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.mjs
+//#region ../../node_modules/.pnpm/@vueuse+core@14.1.0_vue@3.5.25_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js
 const defaultWindow = isClient ? window : void 0;
 const defaultDocument = isClient ? window.document : void 0;
 const defaultNavigator = isClient ? window.navigator : void 0;
 const defaultLocation = isClient ? window.location : void 0;
+/**
+* Get the dom element of a ref of element or Vue component instance
+*
+* @param elRef
+*/
 function unrefElement(elRef) {
-	var _a;
+	var _$el;
 	const plain = toValue(elRef);
-	return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+	return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
 }
 function useEventListener(...args) {
-	const cleanups = [];
-	const cleanup = () => {
-		cleanups.forEach((fn) => fn());
-		cleanups.length = 0;
-	};
 	const register = (el, event, listener, options) => {
 		el.addEventListener(event, listener, options);
 		return () => el.removeEventListener(event, listener, options);
@@ -6138,28 +6161,30 @@ function useEventListener(...args) {
 		const test = toArray(toValue(args[0])).filter((e) => e != null);
 		return test.every((e) => typeof e !== "string") ? test : void 0;
 	});
-	const stopWatch = watchImmediate(() => {
-		var _a, _b;
+	return watchImmediate(() => {
+		var _firstParamTargets$va, _firstParamTargets$va2;
 		return [
-			(_b = (_a = firstParamTargets.value) == null ? void 0 : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null),
+			(_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
 			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;
+	}, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
+		if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
 		const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
-		cleanups.push(...raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone)))));
+		const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+		onCleanup(() => {
+			cleanups.forEach((fn) => fn());
+		});
 	}, { flush: "post" });
-	const stop$1 = () => {
-		stopWatch();
-		cleanup();
-	};
-	tryOnScopeDispose(cleanup);
-	return stop$1;
 }
-/* @__NO_SIDE_EFFECTS__ */
+/**
+* Mounted state in ref.
+*
+* @see https://vueuse.org/useMounted
+*
+* @__NO_SIDE_EFFECTS__
+*/
 function useMounted() {
 	const isMounted = shallowRef(false);
 	const instance = getCurrentInstance();
@@ -6170,14 +6195,23 @@ function useMounted() {
 }
 /* @__NO_SIDE_EFFECTS__ */
 function useSupported(callback) {
-	const isMounted = /* @__PURE__ */ useMounted();
+	const isMounted = useMounted();
 	return computed(() => {
 		isMounted.value;
 		return Boolean(callback());
 	});
 }
+/**
+* Watch for changes being made to the DOM tree.
+*
+* @see https://vueuse.org/useMutationObserver
+* @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver MutationObserver MDN
+* @param target
+* @param callback
+* @param options
+*/
 function useMutationObserver(target, callback, options = {}) {
-	const { window: window$1 = defaultWindow,...mutationOptions } = options;
+	const { window: window$1 = defaultWindow, ...mutationOptions } = options;
 	let observer;
 	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "MutationObserver" in window$1);
 	const cleanup = () => {
@@ -6186,12 +6220,10 @@ function useMutationObserver(target, callback, options = {}) {
 			observer = void 0;
 		}
 	};
-	const targets = computed(() => {
-		const value = toValue(target);
-		const items = toArray(value).map(unrefElement).filter(notNullish);
+	const stopWatch = watch(computed(() => {
+		const items = toArray(toValue(target)).map(unrefElement).filter(notNullish);
 		return new Set(items);
-	});
-	const stopWatch = watch(targets, (newTargets) => {
+	}), (newTargets) => {
 		cleanup();
 		if (isSupported$1.value && newTargets.size) {
 			observer = new MutationObserver(callback);
@@ -6202,7 +6234,7 @@ function useMutationObserver(target, callback, options = {}) {
 		flush: "post"
 	});
 	const takeRecords = () => {
-		return observer == null ? void 0 : observer.takeRecords();
+		return observer === null || observer === void 0 ? void 0 : observer.takeRecords();
 	};
 	const stop$1 = () => {
 		stopWatch();
@@ -6221,6 +6253,13 @@ function useSSRWidth() {
 	const ssrWidth = hasInjectionContext() ? injectLocal(ssrWidthSymbol, null) : null;
 	return typeof ssrWidth === "number" ? ssrWidth : void 0;
 }
+/**
+* Reactive Media Query.
+*
+* @see https://vueuse.org/useMediaQuery
+* @param query
+* @param options
+*/
 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");
@@ -6299,26 +6338,28 @@ const StorageSerializers = {
 	}
 };
 const customStorageEventName = "vueuse-storage";
-function useStorage(key, defaults, storage, options = {}) {
-	var _a;
+/**
+* Reactive LocalStorage/SessionStorage.
+*
+* @see https://vueuse.org/useStorage
+*/
+function useStorage(key, defaults$1, storage, options = {}) {
+	var _options$serializer;
 	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 data = (shallow ? shallowRef : ref)(typeof defaults$1 === "function" ? defaults$1() : defaults$1);
 	const keyComputed = computed(() => toValue(key));
 	if (!storage) try {
-		storage = getSSRHandler("getDefaultStorage", () => {
-			var _a2;
-			return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;
-		})();
+		storage = getSSRHandler("getDefaultStorage", () => defaultWindow === null || defaultWindow === void 0 ? void 0 : defaultWindow.localStorage)();
 	} catch (e) {
 		onError(e);
 	}
 	if (!storage) return data;
-	const rawInit = toValue(defaults);
+	const rawInit = toValue(defaults$1);
 	const type = guessSerializerType(rawInit);
-	const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];
-	const { pause: pauseWatch, resume: resumeWatch } = watchPausable(data, (newValue) => write(newValue), {
+	const serializer = (_options$serializer = options.serializer) !== null && _options$serializer !== void 0 ? _options$serializer : StorageSerializers[type];
+	const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(data, (newValue) => write(newValue), {
 		flush,
 		deep,
 		eventFilter
@@ -6333,6 +6374,12 @@ function useStorage(key, defaults, storage, options = {}) {
 		if (initOnMounted && !firstMounted) return;
 		updateFromCustomEvent(ev);
 	};
+	/**
+	* The custom event is needed for same-document syncing when using custom
+	* storage backends, but it doesn't work across different documents.
+	*
+	* TODO: Consider implementing a BroadcastChannel-based solution that fixes this.
+	*/
 	if (window$1 && listenToStorageChanges) if (storage instanceof Storage) useEventListener(window$1, "storage", onStorageEvent, { passive: true });
 	else useEventListener(window$1, customStorageEventName, onStorageCustomEvent);
 	if (initOnMounted) tryOnMounted(() => {
@@ -6394,7 +6441,7 @@ function useStorage(key, defaults, storage, options = {}) {
 		pauseWatch();
 		try {
 			const serializedData = serializer.write(data.value);
-			if (event === void 0 || (event == null ? void 0 : event.newValue) !== serializedData) data.value = read(event);
+			if (event === void 0 || (event === null || event === void 0 ? void 0 : event.newValue) !== serializedData) data.value = read(event);
 		} catch (e) {
 			onError(e);
 		} finally {
@@ -6407,18 +6454,28 @@ function useStorage(key, defaults, storage, options = {}) {
 	}
 	return data;
 }
+/**
+* Manipulate CSS variables.
+*
+* @see https://vueuse.org/useCssVar
+* @param prop
+* @param target
+* @param options
+*/
 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);
+		var _window$document;
+		return unrefElement(target) || (window$1 === null || window$1 === void 0 || (_window$document = window$1.document) === null || _window$document === void 0 ? void 0 : _window$document.documentElement);
 	});
 	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 (el && window$1 && key) {
+			var _window$getComputedSt;
+			variable.value = ((_window$getComputedSt = window$1.getComputedStyle(el).getPropertyValue(key)) === null || _window$getComputedSt === void 0 ? void 0 : _window$getComputedSt.trim()) || variable.value || initialValue;
+		}
 	}
 	if (observe) useMutationObserver(elRef, updateCssVar, {
 		attributeFilter: ["style", "class"],
@@ -6430,13 +6487,21 @@ function useCssVar(prop, target, options = {}) {
 	}, { 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);
+		if ((el === null || el === void 0 ? 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;
 }
+/**
+* Reports changes to the dimensions of an Element's content or the border-box
+*
+* @see https://vueuse.org/useResizeObserver
+* @param target
+* @param callback
+* @param options
+*/
 function useResizeObserver(target, callback, options = {}) {
-	const { window: window$1 = defaultWindow,...observerOptions } = options;
+	const { window: window$1 = defaultWindow, ...observerOptions } = options;
 	let observer;
 	const isSupported$1 = /* @__PURE__ */ useSupported(() => window$1 && "ResizeObserver" in window$1);
 	const cleanup = () => {
@@ -6445,11 +6510,10 @@ function useResizeObserver(target, callback, options = {}) {
 			observer = void 0;
 		}
 	};
-	const targets = computed(() => {
+	const stopWatch = watch(computed(() => {
 		const _targets = toValue(target);
 		return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];
-	});
-	const stopWatch = watch(targets, (els) => {
+	}), (els) => {
 		cleanup();
 		if (isSupported$1.value && window$1) {
 			observer = new ResizeObserver(callback);
@@ -6469,6 +6533,12 @@ function useResizeObserver(target, callback, options = {}) {
 		stop: stop$1
 	};
 }
+/**
+* Reactive bounding box of an HTML element.
+*
+* @see https://vueuse.org/useElementBounding
+* @param target
+*/
 function useElementBounding(target, options = {}) {
 	const { reset = true, windowResize = true, windowScroll = true, immediate = true, updateTiming = "sync" } = options;
 	const height = shallowRef(0);
@@ -6531,14 +6601,27 @@ function useElementBounding(target, options = {}) {
 		update
 	};
 }
+/**
+* Reactive LocalStorage.
+*
+* @see https://vueuse.org/useLocalStorage
+* @param key
+* @param initialValue
+* @param options
+*/
 function useLocalStorage(key, initialValue, options = {}) {
 	const { window: window$1 = defaultWindow } = options;
-	return useStorage(key, initialValue, window$1 == null ? void 0 : window$1.localStorage, options);
+	return useStorage(key, initialValue, window$1 === null || window$1 === void 0 ? 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";
+/**
+* Reactive `env(safe-area-inset-*)`
+*
+* @see https://vueuse.org/useScreenSafeArea
+*/
 function useScreenSafeArea() {
 	const top = shallowRef("");
 	const right = shallowRef("");
@@ -6610,7 +6693,14 @@ const DEFAULT_UNITS = [
 		name: "year"
 	}
 ];
-/* @__NO_SIDE_EFFECTS__ */
+/**
+* Reactive window size.
+*
+* @see https://vueuse.org/useWindowSize
+* @param options
+*
+* @__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);
@@ -6636,10 +6726,7 @@ function useWindowSize(options = {}) {
 	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());
-	}
+	if (listenOrientation) watch(useMediaQuery("(orientation: portrait)"), () => update());
 	return {
 		width,
 		height
@@ -6647,4 +6734,56 @@ function useWindowSize(options = {}) {
 }
 
 //#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 };
+//#region src/client/webcomponents/state/docks.ts
+function DEFAULT_DOCK_PANEL_STORE() {
+	return {
+		width: 80,
+		height: 80,
+		top: 0,
+		left: 10,
+		position: "bottom",
+		open: false,
+		inactiveTimeout: 3e3
+	};
+}
+function createDockEntryState(entry, selected) {
+	const events = createEventEmitter();
+	const state = reactive({
+		entryMeta: entry,
+		get isActive() {
+			return selected.value?.id === entry.id;
+		},
+		domElements: {},
+		events: markRaw(events)
+	});
+	watch(() => selected.value?.id, (newSelectedId) => {
+		if (newSelectedId === entry.id) events.emitOnce("entry:activated");
+		else events.emitOnce("entry:deactivated");
+	}, { immediate: true });
+	watch(() => state.domElements.iframe, (newIframe) => {
+		if (newIframe) events.emitOnce("dom:iframe:mounted", newIframe);
+	}, { immediate: true });
+	watch(() => state.domElements.panel, (newPanel) => {
+		if (newPanel) events.emitOnce("dom:panel:mounted", newPanel);
+	}, { immediate: true });
+	return state;
+}
+let _docksEntriesRef;
+async function useDocksEntries(rpc) {
+	if (_docksEntriesRef) return _docksEntriesRef;
+	const dockEntries = _docksEntriesRef = shallowRef([]);
+	async function updateDocksEntries() {
+		dockEntries.value = (await rpc.call("vite:internal:docks:list")).map((entry) => Object.freeze(entry));
+		console.log("[VITE DEVTOOLS] Docks Entries Updated", [...dockEntries.value]);
+	}
+	rpc.client.register({
+		name: "vite:internal:docks:updated",
+		type: "action",
+		handler: () => updateDocksEntries()
+	});
+	await updateDocksEntries();
+	return dockEntries;
+}
+
+//#endregion
+export { watchEffect as A, normalizeStyle as B, onMounted as C, renderSlot as D, renderList as E, ref as F, shallowRef as I, toRefs$1 as L, withDirectives as M, markRaw as N, useTemplateRef as O, reactive as P, unref as R, nextTick as S, openBlock as T, toDisplayString as V, createCommentVNode as _, useEventListener as a, createVNode as b, useWindowSize as c, vShow as d, withModifiers as f, createBlock as g, createBaseVNode as h, useElementBounding as i, withCtx as j, watch as k, watchImmediate as l, computed as m, createDockEntryState as n, useLocalStorage as o, Fragment as p, useDocksEntries as r, useScreenSafeArea as s, DEFAULT_DOCK_PANEL_STORE as t, defineCustomElement as u, createElementBlock as v, onUnmounted as w, defineComponent as x, createStaticVNode as y, normalizeClass as z };