nuxt-intlayer 7.0.0-canary.3 → 7.0.0

package/dist/cjs/node_modules/.bun/@vue_runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.cjs.prod.cjs

@@ -1,4204 +0,0 @@
-const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.cjs');
-const require_index = require('../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/index.cjs');
-const require_index$1 = require('../../../../../@vue_reactivity@3.5.22/node_modules/@vue/reactivity/index.cjs');
-
-//#region ../../node_modules/.bun/@vue+runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.cjs.prod.js
-var require_runtime_core_cjs_prod = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.bun/@vue+runtime-core@3.5.22/node_modules/@vue/runtime-core/dist/runtime-core.cjs.prod.js": ((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	var reactivity = require_index$1.require_reactivity();
-	var shared = require_index.require_shared();
-	function pushWarningContext(vnode) {}
-	function popWarningContext() {}
-	function assertNumber(val, type) {}
-	const ErrorCodes = {
-		"SETUP_FUNCTION": 0,
-		"0": "SETUP_FUNCTION",
-		"RENDER_FUNCTION": 1,
-		"1": "RENDER_FUNCTION",
-		"NATIVE_EVENT_HANDLER": 5,
-		"5": "NATIVE_EVENT_HANDLER",
-		"COMPONENT_EVENT_HANDLER": 6,
-		"6": "COMPONENT_EVENT_HANDLER",
-		"VNODE_HOOK": 7,
-		"7": "VNODE_HOOK",
-		"DIRECTIVE_HOOK": 8,
-		"8": "DIRECTIVE_HOOK",
-		"TRANSITION_HOOK": 9,
-		"9": "TRANSITION_HOOK",
-		"APP_ERROR_HANDLER": 10,
-		"10": "APP_ERROR_HANDLER",
-		"APP_WARN_HANDLER": 11,
-		"11": "APP_WARN_HANDLER",
-		"FUNCTION_REF": 12,
-		"12": "FUNCTION_REF",
-		"ASYNC_COMPONENT_LOADER": 13,
-		"13": "ASYNC_COMPONENT_LOADER",
-		"SCHEDULER": 14,
-		"14": "SCHEDULER",
-		"COMPONENT_UPDATE": 15,
-		"15": "COMPONENT_UPDATE",
-		"APP_UNMOUNT_CLEANUP": 16,
-		"16": "APP_UNMOUNT_CLEANUP"
-	};
-	const ErrorTypeStrings$1 = {
-		["sp"]: "serverPrefetch hook",
-		["bc"]: "beforeCreate hook",
-		["c"]: "created hook",
-		["bm"]: "beforeMount hook",
-		["m"]: "mounted hook",
-		["bu"]: "beforeUpdate hook",
-		["u"]: "updated",
-		["bum"]: "beforeUnmount hook",
-		["um"]: "unmounted hook",
-		["a"]: "activated hook",
-		["da"]: "deactivated hook",
-		["ec"]: "errorCaptured hook",
-		["rtc"]: "renderTracked hook",
-		["rtg"]: "renderTriggered hook",
-		[0]: "setup function",
-		[1]: "render function",
-		[2]: "watcher getter",
-		[3]: "watcher callback",
-		[4]: "watcher cleanup function",
-		[5]: "native event handler",
-		[6]: "component event handler",
-		[7]: "vnode hook",
-		[8]: "directive hook",
-		[9]: "transition hook",
-		[10]: "app errorHandler",
-		[11]: "app warnHandler",
-		[12]: "ref function",
-		[13]: "async component loader",
-		[14]: "scheduler flush",
-		[15]: "component update",
-		[16]: "app unmount cleanup function"
-	};
-	function callWithErrorHandling(fn, instance, type, args) {
-		try {
-			return args ? fn(...args) : fn();
-		} catch (err) {
-			handleError(err, instance, type);
-		}
-	}
-	function callWithAsyncErrorHandling(fn, instance, type, args) {
-		if (shared.isFunction(fn)) {
-			const res = callWithErrorHandling(fn, instance, type, args);
-			if (res && shared.isPromise(res)) res.catch((err) => {
-				handleError(err, instance, type);
-			});
-			return res;
-		}
-		if (shared.isArray(fn)) {
-			const values = [];
-			for (let i = 0; i < fn.length; i++) values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
-			return values;
-		}
-	}
-	function handleError(err, instance, type, throwInDev = true) {
-		const contextVNode = instance ? instance.vnode : null;
-		const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || shared.EMPTY_OBJ;
-		if (instance) {
-			let cur = instance.parent;
-			const exposedInstance = instance.proxy;
-			const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
-			while (cur) {
-				const errorCapturedHooks = cur.ec;
-				if (errorCapturedHooks) {
-					for (let i = 0; i < errorCapturedHooks.length; i++) if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) return;
-				}
-				cur = cur.parent;
-			}
-			if (errorHandler) {
-				reactivity.pauseTracking();
-				callWithErrorHandling(errorHandler, null, 10, [
-					err,
-					exposedInstance,
-					errorInfo
-				]);
-				reactivity.resetTracking();
-				return;
-			}
-		}
-		logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
-	}
-	function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
-		if (throwInProd) throw err;
-		else console.error(err);
-	}
-	const queue = [];
-	let flushIndex = -1;
-	const pendingPostFlushCbs = [];
-	let activePostFlushCbs = null;
-	let postFlushIndex = 0;
-	const resolvedPromise = /* @__PURE__ */ Promise.resolve();
-	let currentFlushPromise = null;
-	function nextTick(fn) {
-		const p = currentFlushPromise || resolvedPromise;
-		return fn ? p.then(this ? fn.bind(this) : fn) : p;
-	}
-	function findInsertionIndex(id) {
-		let start = flushIndex + 1;
-		let end = queue.length;
-		while (start < end) {
-			const middle = start + end >>> 1;
-			const middleJob = queue[middle];
-			const middleJobId = getId(middleJob);
-			if (middleJobId < id || middleJobId === id && middleJob.flags & 2) start = middle + 1;
-			else end = middle;
-		}
-		return start;
-	}
-	function queueJob(job) {
-		if (!(job.flags & 1)) {
-			const jobId = getId(job);
-			const lastJob = queue[queue.length - 1];
-			if (!lastJob || !(job.flags & 2) && jobId >= getId(lastJob)) queue.push(job);
-			else queue.splice(findInsertionIndex(jobId), 0, job);
-			job.flags |= 1;
-			queueFlush();
-		}
-	}
-	function queueFlush() {
-		if (!currentFlushPromise) currentFlushPromise = resolvedPromise.then(flushJobs);
-	}
-	function queuePostFlushCb(cb) {
-		if (!shared.isArray(cb)) {
-			if (activePostFlushCbs && cb.id === -1) activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
-			else if (!(cb.flags & 1)) {
-				pendingPostFlushCbs.push(cb);
-				cb.flags |= 1;
-			}
-		} else pendingPostFlushCbs.push(...cb);
-		queueFlush();
-	}
-	function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
-		for (; i < queue.length; i++) {
-			const cb = queue[i];
-			if (cb && cb.flags & 2) {
-				if (instance && cb.id !== instance.uid) continue;
-				queue.splice(i, 1);
-				i--;
-				if (cb.flags & 4) cb.flags &= -2;
-				cb();
-				if (!(cb.flags & 4)) cb.flags &= -2;
-			}
-		}
-	}
-	function flushPostFlushCbs(seen) {
-		if (pendingPostFlushCbs.length) {
-			const deduped = [...new Set(pendingPostFlushCbs)].sort((a, b) => getId(a) - getId(b));
-			pendingPostFlushCbs.length = 0;
-			if (activePostFlushCbs) {
-				activePostFlushCbs.push(...deduped);
-				return;
-			}
-			activePostFlushCbs = deduped;
-			for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
-				const cb = activePostFlushCbs[postFlushIndex];
-				if (cb.flags & 4) cb.flags &= -2;
-				if (!(cb.flags & 8)) cb();
-				cb.flags &= -2;
-			}
-			activePostFlushCbs = null;
-			postFlushIndex = 0;
-		}
-	}
-	const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
-	function flushJobs(seen) {
-		try {
-			for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
-				const job = queue[flushIndex];
-				if (job && !(job.flags & 8)) {
-					if (job.flags & 4) job.flags &= -2;
-					callWithErrorHandling(job, job.i, job.i ? 15 : 14);
-					if (!(job.flags & 4)) job.flags &= -2;
-				}
-			}
-		} finally {
-			for (; flushIndex < queue.length; flushIndex++) {
-				const job = queue[flushIndex];
-				if (job) job.flags &= -2;
-			}
-			flushIndex = -1;
-			queue.length = 0;
-			flushPostFlushCbs();
-			currentFlushPromise = null;
-			if (queue.length || pendingPostFlushCbs.length) flushJobs();
-		}
-	}
-	let currentRenderingInstance = null;
-	let currentScopeId = null;
-	function setCurrentRenderingInstance(instance) {
-		const prev = currentRenderingInstance;
-		currentRenderingInstance = instance;
-		currentScopeId = instance && instance.type.__scopeId || null;
-		return prev;
-	}
-	function pushScopeId(id) {
-		currentScopeId = id;
-	}
-	function popScopeId() {
-		currentScopeId = null;
-	}
-	const withScopeId = (_id) => withCtx;
-	function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
-		if (!ctx) return fn;
-		if (fn._n) return fn;
-		const renderFnWithContext = (...args) => {
-			if (renderFnWithContext._d) setBlockTracking(-1);
-			const prevInstance = setCurrentRenderingInstance(ctx);
-			let res;
-			try {
-				res = fn(...args);
-			} finally {
-				setCurrentRenderingInstance(prevInstance);
-				if (renderFnWithContext._d) setBlockTracking(1);
-			}
-			return res;
-		};
-		renderFnWithContext._n = true;
-		renderFnWithContext._c = true;
-		renderFnWithContext._d = true;
-		return renderFnWithContext;
-	}
-	function withDirectives(vnode, directives) {
-		if (currentRenderingInstance === null) return vnode;
-		const instance = getComponentPublicInstance(currentRenderingInstance);
-		const bindings = vnode.dirs || (vnode.dirs = []);
-		for (let i = 0; i < directives.length; i++) {
-			let [dir, value, arg, modifiers = shared.EMPTY_OBJ] = directives[i];
-			if (dir) {
-				if (shared.isFunction(dir)) dir = {
-					mounted: dir,
-					updated: dir
-				};
-				if (dir.deep) reactivity.traverse(value);
-				bindings.push({
-					dir,
-					instance,
-					value,
-					oldValue: void 0,
-					arg,
-					modifiers
-				});
-			}
-		}
-		return vnode;
-	}
-	function invokeDirectiveHook(vnode, prevVNode, instance, name) {
-		const bindings = vnode.dirs;
-		const oldBindings = prevVNode && prevVNode.dirs;
-		for (let i = 0; i < bindings.length; i++) {
-			const binding = bindings[i];
-			if (oldBindings) binding.oldValue = oldBindings[i].value;
-			let hook = binding.dir[name];
-			if (hook) {
-				reactivity.pauseTracking();
-				callWithAsyncErrorHandling(hook, instance, 8, [
-					vnode.el,
-					binding,
-					vnode,
-					prevVNode
-				]);
-				reactivity.resetTracking();
-			}
-		}
-	}
-	const TeleportEndKey = Symbol("_vte");
-	const isTeleport = (type) => type.__isTeleport;
-	const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
-	const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
-	const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
-	const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
-	const resolveTarget = (props, select) => {
-		const targetSelector = props && props.to;
-		if (shared.isString(targetSelector)) if (!select) return null;
-		else return select(targetSelector);
-		else return targetSelector;
-	};
-	const TeleportImpl = {
-		name: "Teleport",
-		__isTeleport: true,
-		process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
-			const { mc: mountChildren, pc: patchChildren, pbc: patchBlockChildren, o: { insert, querySelector, createText, createComment } } = internals;
-			const disabled = isTeleportDisabled(n2.props);
-			let { shapeFlag, children, dynamicChildren } = n2;
-			if (n1 == null) {
-				const placeholder = n2.el = createText("");
-				const mainAnchor = n2.anchor = createText("");
-				insert(placeholder, container, anchor);
-				insert(mainAnchor, container, anchor);
-				const mount = (container2, anchor2) => {
-					if (shapeFlag & 16) mountChildren(children, container2, anchor2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-				};
-				const mountToTarget = () => {
-					const target = n2.target = resolveTarget(n2.props, querySelector);
-					const targetAnchor = prepareAnchor(target, n2, createText, insert);
-					if (target) {
-						if (namespace !== "svg" && isTargetSVG(target)) namespace = "svg";
-						else if (namespace !== "mathml" && isTargetMathML(target)) namespace = "mathml";
-						if (parentComponent && parentComponent.isCE) (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
-						if (!disabled) {
-							mount(target, targetAnchor);
-							updateCssVars(n2, false);
-						}
-					}
-				};
-				if (disabled) {
-					mount(container, mainAnchor);
-					updateCssVars(n2, true);
-				}
-				if (isTeleportDeferred(n2.props)) {
-					n2.el.__isMounted = false;
-					queuePostRenderEffect(() => {
-						mountToTarget();
-						delete n2.el.__isMounted;
-					}, parentSuspense);
-				} else mountToTarget();
-			} else {
-				if (isTeleportDeferred(n2.props) && n1.el.__isMounted === false) {
-					queuePostRenderEffect(() => {
-						TeleportImpl.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals);
-					}, parentSuspense);
-					return;
-				}
-				n2.el = n1.el;
-				n2.targetStart = n1.targetStart;
-				const mainAnchor = n2.anchor = n1.anchor;
-				const target = n2.target = n1.target;
-				const targetAnchor = n2.targetAnchor = n1.targetAnchor;
-				const wasDisabled = isTeleportDisabled(n1.props);
-				const currentContainer = wasDisabled ? container : target;
-				const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
-				if (namespace === "svg" || isTargetSVG(target)) namespace = "svg";
-				else if (namespace === "mathml" || isTargetMathML(target)) namespace = "mathml";
-				if (dynamicChildren) {
-					patchBlockChildren(n1.dynamicChildren, dynamicChildren, currentContainer, parentComponent, parentSuspense, namespace, slotScopeIds);
-					traverseStaticChildren(n1, n2, true);
-				} else if (!optimized) patchChildren(n1, n2, currentContainer, currentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, false);
-				if (disabled) {
-					if (!wasDisabled) moveTeleport(n2, container, mainAnchor, internals, 1);
-					else if (n2.props && n1.props && n2.props.to !== n1.props.to) n2.props.to = n1.props.to;
-				} else if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
-					const nextTarget = n2.target = resolveTarget(n2.props, querySelector);
-					if (nextTarget) moveTeleport(n2, nextTarget, null, internals, 0);
-				} else if (wasDisabled) moveTeleport(n2, target, targetAnchor, internals, 1);
-				updateCssVars(n2, disabled);
-			}
-		},
-		remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
-			const { shapeFlag, children, anchor, targetStart, targetAnchor, target, props } = vnode;
-			if (target) {
-				hostRemove(targetStart);
-				hostRemove(targetAnchor);
-			}
-			doRemove && hostRemove(anchor);
-			if (shapeFlag & 16) {
-				const shouldRemove = doRemove || !isTeleportDisabled(props);
-				for (let i = 0; i < children.length; i++) {
-					const child = children[i];
-					unmount(child, parentComponent, parentSuspense, shouldRemove, !!child.dynamicChildren);
-				}
-			}
-		},
-		move: moveTeleport,
-		hydrate: hydrateTeleport
-	};
-	function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
-		if (moveType === 0) insert(vnode.targetAnchor, container, parentAnchor);
-		const { el, anchor, shapeFlag, children, props } = vnode;
-		const isReorder = moveType === 2;
-		if (isReorder) insert(el, container, parentAnchor);
-		if (!isReorder || isTeleportDisabled(props)) {
-			if (shapeFlag & 16) for (let i = 0; i < children.length; i++) move(children[i], container, parentAnchor, 2);
-		}
-		if (isReorder) insert(anchor, container, parentAnchor);
-	}
-	function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, { o: { nextSibling, parentNode, querySelector, insert, createText } }, hydrateChildren) {
-		function hydrateDisabledTeleport(node2, vnode2, targetStart, targetAnchor) {
-			vnode2.anchor = hydrateChildren(nextSibling(node2), vnode2, parentNode(node2), parentComponent, parentSuspense, slotScopeIds, optimized);
-			vnode2.targetStart = targetStart;
-			vnode2.targetAnchor = targetAnchor;
-		}
-		const target = vnode.target = resolveTarget(vnode.props, querySelector);
-		const disabled = isTeleportDisabled(vnode.props);
-		if (target) {
-			const targetNode = target._lpa || target.firstChild;
-			if (vnode.shapeFlag & 16) if (disabled) hydrateDisabledTeleport(node, vnode, targetNode, targetNode && nextSibling(targetNode));
-			else {
-				vnode.anchor = nextSibling(node);
-				let targetAnchor = targetNode;
-				while (targetAnchor) {
-					if (targetAnchor && targetAnchor.nodeType === 8) {
-						if (targetAnchor.data === "teleport start anchor") vnode.targetStart = targetAnchor;
-						else if (targetAnchor.data === "teleport anchor") {
-							vnode.targetAnchor = targetAnchor;
-							target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
-							break;
-						}
-					}
-					targetAnchor = nextSibling(targetAnchor);
-				}
-				if (!vnode.targetAnchor) prepareAnchor(target, vnode, createText, insert);
-				hydrateChildren(targetNode && nextSibling(targetNode), vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized);
-			}
-			updateCssVars(vnode, disabled);
-		} else if (disabled) {
-			if (vnode.shapeFlag & 16) hydrateDisabledTeleport(node, vnode, node, nextSibling(node));
-		}
-		return vnode.anchor && nextSibling(vnode.anchor);
-	}
-	const Teleport = TeleportImpl;
-	function updateCssVars(vnode, isDisabled) {
-		const ctx = vnode.ctx;
-		if (ctx && ctx.ut) {
-			let node, anchor;
-			if (isDisabled) {
-				node = vnode.el;
-				anchor = vnode.anchor;
-			} else {
-				node = vnode.targetStart;
-				anchor = vnode.targetAnchor;
-			}
-			while (node && node !== anchor) {
-				if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
-				node = node.nextSibling;
-			}
-			ctx.ut();
-		}
-	}
-	function prepareAnchor(target, vnode, createText, insert) {
-		const targetStart = vnode.targetStart = createText("");
-		const targetAnchor = vnode.targetAnchor = createText("");
-		targetStart[TeleportEndKey] = targetAnchor;
-		if (target) {
-			insert(targetStart, target);
-			insert(targetAnchor, target);
-		}
-		return targetAnchor;
-	}
-	const leaveCbKey = Symbol("_leaveCb");
-	const enterCbKey = Symbol("_enterCb");
-	function useTransitionState() {
-		const state = {
-			isMounted: false,
-			isLeaving: false,
-			isUnmounting: false,
-			leavingVNodes: /* @__PURE__ */ new Map()
-		};
-		onMounted(() => {
-			state.isMounted = true;
-		});
-		onBeforeUnmount(() => {
-			state.isUnmounting = true;
-		});
-		return state;
-	}
-	const TransitionHookValidator = [Function, Array];
-	const BaseTransitionPropsValidators = {
-		mode: String,
-		appear: Boolean,
-		persisted: Boolean,
-		onBeforeEnter: TransitionHookValidator,
-		onEnter: TransitionHookValidator,
-		onAfterEnter: TransitionHookValidator,
-		onEnterCancelled: TransitionHookValidator,
-		onBeforeLeave: TransitionHookValidator,
-		onLeave: TransitionHookValidator,
-		onAfterLeave: TransitionHookValidator,
-		onLeaveCancelled: TransitionHookValidator,
-		onBeforeAppear: TransitionHookValidator,
-		onAppear: TransitionHookValidator,
-		onAfterAppear: TransitionHookValidator,
-		onAppearCancelled: TransitionHookValidator
-	};
-	const recursiveGetSubtree = (instance) => {
-		const subTree = instance.subTree;
-		return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
-	};
-	const BaseTransitionImpl = {
-		name: `BaseTransition`,
-		props: BaseTransitionPropsValidators,
-		setup(props, { slots }) {
-			const instance = getCurrentInstance();
-			const state = useTransitionState();
-			return () => {
-				const children = slots.default && getTransitionRawChildren(slots.default(), true);
-				if (!children || !children.length) return;
-				const child = findNonCommentChild(children);
-				const rawProps = reactivity.toRaw(props);
-				const { mode } = rawProps;
-				if (state.isLeaving) return emptyPlaceholder(child);
-				const innerChild = getInnerChild$1(child);
-				if (!innerChild) return emptyPlaceholder(child);
-				let enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance, (hooks) => enterHooks = hooks);
-				if (innerChild.type !== Comment) setTransitionHooks(innerChild, enterHooks);
-				let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
-				if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && recursiveGetSubtree(instance).type !== Comment) {
-					let leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance);
-					setTransitionHooks(oldInnerChild, leavingHooks);
-					if (mode === "out-in" && innerChild.type !== Comment) {
-						state.isLeaving = true;
-						leavingHooks.afterLeave = () => {
-							state.isLeaving = false;
-							if (!(instance.job.flags & 8)) instance.update();
-							delete leavingHooks.afterLeave;
-							oldInnerChild = void 0;
-						};
-						return emptyPlaceholder(child);
-					} else if (mode === "in-out" && innerChild.type !== Comment) leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
-						const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild);
-						leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
-						el[leaveCbKey] = () => {
-							earlyRemove();
-							el[leaveCbKey] = void 0;
-							delete enterHooks.delayedLeave;
-							oldInnerChild = void 0;
-						};
-						enterHooks.delayedLeave = () => {
-							delayedLeave();
-							delete enterHooks.delayedLeave;
-							oldInnerChild = void 0;
-						};
-					};
-					else oldInnerChild = void 0;
-				} else if (oldInnerChild) oldInnerChild = void 0;
-				return child;
-			};
-		}
-	};
-	function findNonCommentChild(children) {
-		let child = children[0];
-		if (children.length > 1) {
-			for (const c of children) if (c.type !== Comment) {
-				child = c;
-				break;
-			}
-		}
-		return child;
-	}
-	const BaseTransition = BaseTransitionImpl;
-	function getLeavingNodesForType(state, vnode) {
-		const { leavingVNodes } = state;
-		let leavingVNodesCache = leavingVNodes.get(vnode.type);
-		if (!leavingVNodesCache) {
-			leavingVNodesCache = /* @__PURE__ */ Object.create(null);
-			leavingVNodes.set(vnode.type, leavingVNodesCache);
-		}
-		return leavingVNodesCache;
-	}
-	function resolveTransitionHooks(vnode, props, state, instance, postClone) {
-		const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props;
-		const key = String(vnode.key);
-		const leavingVNodesCache = getLeavingNodesForType(state, vnode);
-		const callHook$1 = (hook, args) => {
-			hook && callWithAsyncErrorHandling(hook, instance, 9, args);
-		};
-		const callAsyncHook = (hook, args) => {
-			const done = args[1];
-			callHook$1(hook, args);
-			if (shared.isArray(hook)) {
-				if (hook.every((hook2) => hook2.length <= 1)) done();
-			} else if (hook.length <= 1) done();
-		};
-		const hooks = {
-			mode,
-			persisted,
-			beforeEnter(el) {
-				let hook = onBeforeEnter;
-				if (!state.isMounted) if (appear) hook = onBeforeAppear || onBeforeEnter;
-				else return;
-				if (el[leaveCbKey]) el[leaveCbKey](true);
-				const leavingVNode = leavingVNodesCache[key];
-				if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) leavingVNode.el[leaveCbKey]();
-				callHook$1(hook, [el]);
-			},
-			enter(el) {
-				let hook = onEnter;
-				let afterHook = onAfterEnter;
-				let cancelHook = onEnterCancelled;
-				if (!state.isMounted) if (appear) {
-					hook = onAppear || onEnter;
-					afterHook = onAfterAppear || onAfterEnter;
-					cancelHook = onAppearCancelled || onEnterCancelled;
-				} else return;
-				let called = false;
-				const done = el[enterCbKey] = (cancelled) => {
-					if (called) return;
-					called = true;
-					if (cancelled) callHook$1(cancelHook, [el]);
-					else callHook$1(afterHook, [el]);
-					if (hooks.delayedLeave) hooks.delayedLeave();
-					el[enterCbKey] = void 0;
-				};
-				if (hook) callAsyncHook(hook, [el, done]);
-				else done();
-			},
-			leave(el, remove) {
-				const key2 = String(vnode.key);
-				if (el[enterCbKey]) el[enterCbKey](true);
-				if (state.isUnmounting) return remove();
-				callHook$1(onBeforeLeave, [el]);
-				let called = false;
-				const done = el[leaveCbKey] = (cancelled) => {
-					if (called) return;
-					called = true;
-					remove();
-					if (cancelled) callHook$1(onLeaveCancelled, [el]);
-					else callHook$1(onAfterLeave, [el]);
-					el[leaveCbKey] = void 0;
-					if (leavingVNodesCache[key2] === vnode) delete leavingVNodesCache[key2];
-				};
-				leavingVNodesCache[key2] = vnode;
-				if (onLeave) callAsyncHook(onLeave, [el, done]);
-				else done();
-			},
-			clone(vnode2) {
-				const hooks2 = resolveTransitionHooks(vnode2, props, state, instance, postClone);
-				if (postClone) postClone(hooks2);
-				return hooks2;
-			}
-		};
-		return hooks;
-	}
-	function emptyPlaceholder(vnode) {
-		if (isKeepAlive(vnode)) {
-			vnode = cloneVNode(vnode);
-			vnode.children = null;
-			return vnode;
-		}
-	}
-	function getInnerChild$1(vnode) {
-		if (!isKeepAlive(vnode)) {
-			if (isTeleport(vnode.type) && vnode.children) return findNonCommentChild(vnode.children);
-			return vnode;
-		}
-		if (vnode.component) return vnode.component.subTree;
-		const { shapeFlag, children } = vnode;
-		if (children) {
-			if (shapeFlag & 16) return children[0];
-			if (shapeFlag & 32 && shared.isFunction(children.default)) return children.default();
-		}
-	}
-	function setTransitionHooks(vnode, hooks) {
-		if (vnode.shapeFlag & 6 && vnode.component) {
-			vnode.transition = hooks;
-			setTransitionHooks(vnode.component.subTree, hooks);
-		} else if (vnode.shapeFlag & 128) {
-			vnode.ssContent.transition = hooks.clone(vnode.ssContent);
-			vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
-		} else vnode.transition = hooks;
-	}
-	function getTransitionRawChildren(children, keepComment = false, parentKey) {
-		let ret = [];
-		let keyedFragmentCount = 0;
-		for (let i = 0; i < children.length; i++) {
-			let child = children[i];
-			const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
-			if (child.type === Fragment) {
-				if (child.patchFlag & 128) keyedFragmentCount++;
-				ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));
-			} else if (keepComment || child.type !== Comment) ret.push(key != null ? cloneVNode(child, { key }) : child);
-		}
-		if (keyedFragmentCount > 1) for (let i = 0; i < ret.length; i++) ret[i].patchFlag = -2;
-		return ret;
-	}
-	/* @__NO_SIDE_EFFECTS__ */
-	function defineComponent(options, extraOptions) {
-		return shared.isFunction(options) ? /* @__PURE__ */ (() => shared.extend({ name: options.name }, extraOptions, { setup: options }))() : options;
-	}
-	function useId() {
-		const i = getCurrentInstance();
-		if (i) return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
-		return "";
-	}
-	function markAsyncBoundary(instance) {
-		instance.ids = [
-			instance.ids[0] + instance.ids[2]++ + "-",
-			0,
-			0
-		];
-	}
-	function useTemplateRef(key) {
-		const i = getCurrentInstance();
-		const r = reactivity.shallowRef(null);
-		if (i) {
-			const refs = i.refs === shared.EMPTY_OBJ ? i.refs = {} : i.refs;
-			Object.defineProperty(refs, key, {
-				enumerable: true,
-				get: () => r.value,
-				set: (val) => r.value = val
-			});
-		}
-		return r;
-	}
-	const pendingSetRefMap = /* @__PURE__ */ new WeakMap();
-	function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
-		if (shared.isArray(rawRef)) {
-			rawRef.forEach((r, i) => setRef(r, oldRawRef && (shared.isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount));
-			return;
-		}
-		if (isAsyncWrapper(vnode) && !isUnmount) {
-			if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree);
-			return;
-		}
-		const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
-		const value = isUnmount ? null : refValue;
-		const { i: owner, r: ref } = rawRef;
-		const oldRef = oldRawRef && oldRawRef.r;
-		const refs = owner.refs === shared.EMPTY_OBJ ? owner.refs = {} : owner.refs;
-		const setupState = owner.setupState;
-		const rawSetupState = reactivity.toRaw(setupState);
-		const canSetSetupRef = setupState === shared.EMPTY_OBJ ? shared.NO : (key) => {
-			return shared.hasOwn(rawSetupState, key);
-		};
-		if (oldRef != null && oldRef !== ref) {
-			invalidatePendingSetRef(oldRawRef);
-			if (shared.isString(oldRef)) {
-				refs[oldRef] = null;
-				if (canSetSetupRef(oldRef)) setupState[oldRef] = null;
-			} else if (reactivity.isRef(oldRef)) {
-				oldRef.value = null;
-				const oldRawRefAtom = oldRawRef;
-				if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
-			}
-		}
-		if (shared.isFunction(ref)) callWithErrorHandling(ref, owner, 12, [value, refs]);
-		else {
-			const _isString = shared.isString(ref);
-			const _isRef = reactivity.isRef(ref);
-			if (_isString || _isRef) {
-				const doSet = () => {
-					if (rawRef.f) {
-						const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value;
-						if (isUnmount) shared.isArray(existing) && shared.remove(existing, refValue);
-						else if (!shared.isArray(existing)) if (_isString) {
-							refs[ref] = [refValue];
-							if (canSetSetupRef(ref)) setupState[ref] = refs[ref];
-						} else {
-							const newVal = [refValue];
-							ref.value = newVal;
-							if (rawRef.k) refs[rawRef.k] = newVal;
-						}
-						else if (!existing.includes(refValue)) existing.push(refValue);
-					} else if (_isString) {
-						refs[ref] = value;
-						if (canSetSetupRef(ref)) setupState[ref] = value;
-					} else if (_isRef) {
-						ref.value = value;
-						if (rawRef.k) refs[rawRef.k] = value;
-					}
-				};
-				if (value) {
-					const job = () => {
-						doSet();
-						pendingSetRefMap.delete(rawRef);
-					};
-					job.id = -1;
-					pendingSetRefMap.set(rawRef, job);
-					queuePostRenderEffect(job, parentSuspense);
-				} else {
-					invalidatePendingSetRef(rawRef);
-					doSet();
-				}
-			}
-		}
-	}
-	function invalidatePendingSetRef(rawRef) {
-		const pendingSetRef = pendingSetRefMap.get(rawRef);
-		if (pendingSetRef) {
-			pendingSetRef.flags |= 8;
-			pendingSetRefMap.delete(rawRef);
-		}
-	}
-	let hasLoggedMismatchError = false;
-	const logMismatchError = () => {
-		if (hasLoggedMismatchError) return;
-		console.error("Hydration completed but contains mismatches.");
-		hasLoggedMismatchError = true;
-	};
-	const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
-	const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
-	const getContainerType = (container) => {
-		if (container.nodeType !== 1) return void 0;
-		if (isSVGContainer(container)) return "svg";
-		if (isMathMLContainer(container)) return "mathml";
-	};
-	const isComment = (node) => node.nodeType === 8;
-	function createHydrationFunctions(rendererInternals) {
-		const { mt: mountComponent, p: patch, o: { patchProp, createText, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals;
-		const hydrate = (vnode, container) => {
-			if (!container.hasChildNodes()) {
-				patch(null, vnode, container);
-				flushPostFlushCbs();
-				container._vnode = vnode;
-				return;
-			}
-			hydrateNode(container.firstChild, vnode, null, null, null);
-			flushPostFlushCbs();
-			container._vnode = vnode;
-		};
-		const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
-			optimized = optimized || !!vnode.dynamicChildren;
-			const isFragmentStart = isComment(node) && node.data === "[";
-			const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart);
-			const { type, ref, shapeFlag, patchFlag } = vnode;
-			let domType = node.nodeType;
-			vnode.el = node;
-			if (patchFlag === -2) {
-				optimized = false;
-				vnode.dynamicChildren = null;
-			}
-			let nextNode = null;
-			switch (type) {
-				case Text:
-					if (domType !== 3) if (vnode.children === "") {
-						insert(vnode.el = createText(""), parentNode(node), node);
-						nextNode = node;
-					} else nextNode = onMismatch();
-					else {
-						if (node.data !== vnode.children) {
-							logMismatchError();
-							node.data = vnode.children;
-						}
-						nextNode = nextSibling(node);
-					}
-					break;
-				case Comment:
-					if (isTemplateNode(node)) {
-						nextNode = nextSibling(node);
-						replaceNode(vnode.el = node.content.firstChild, node, parentComponent);
-					} else if (domType !== 8 || isFragmentStart) nextNode = onMismatch();
-					else nextNode = nextSibling(node);
-					break;
-				case Static:
-					if (isFragmentStart) {
-						node = nextSibling(node);
-						domType = node.nodeType;
-					}
-					if (domType === 1 || domType === 3) {
-						nextNode = node;
-						const needToAdoptContent = !vnode.children.length;
-						for (let i = 0; i < vnode.staticCount; i++) {
-							if (needToAdoptContent) vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
-							if (i === vnode.staticCount - 1) vnode.anchor = nextNode;
-							nextNode = nextSibling(nextNode);
-						}
-						return isFragmentStart ? nextSibling(nextNode) : nextNode;
-					} else onMismatch();
-					break;
-				case Fragment:
-					if (!isFragmentStart) nextNode = onMismatch();
-					else nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
-					break;
-				default: if (shapeFlag & 1) if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) nextNode = onMismatch();
-				else nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
-				else if (shapeFlag & 6) {
-					vnode.slotScopeIds = slotScopeIds;
-					const container = parentNode(node);
-					if (isFragmentStart) nextNode = locateClosingAnchor(node);
-					else if (isComment(node) && node.data === "teleport start") nextNode = locateClosingAnchor(node, node.data, "teleport end");
-					else nextNode = nextSibling(node);
-					mountComponent(vnode, container, null, parentComponent, parentSuspense, getContainerType(container), optimized);
-					if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) {
-						let subTree;
-						if (isFragmentStart) {
-							subTree = createVNode(Fragment);
-							subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
-						} else subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
-						subTree.el = node;
-						vnode.component.subTree = subTree;
-					}
-				} else if (shapeFlag & 64) if (domType !== 8) nextNode = onMismatch();
-				else nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren);
-				else if (shapeFlag & 128) nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, getContainerType(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode);
-			}
-			if (ref != null) setRef(ref, null, parentSuspense, vnode);
-			return nextNode;
-		};
-		const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
-			optimized = optimized || !!vnode.dynamicChildren;
-			const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
-			const forcePatch = type === "input" || type === "option";
-			if (forcePatch || patchFlag !== -1) {
-				if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "created");
-				let needCallTransitionHooks = false;
-				if (isTemplateNode(el)) {
-					needCallTransitionHooks = needTransition(null, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
-					const content = el.content.firstChild;
-					if (needCallTransitionHooks) {
-						const cls = content.getAttribute("class");
-						if (cls) content.$cls = cls;
-						transition.beforeEnter(content);
-					}
-					replaceNode(content, el, parentComponent);
-					vnode.el = el = content;
-				}
-				if (shapeFlag & 16 && !(props && (props.innerHTML || props.textContent))) {
-					let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized);
-					while (next) {
-						if (!isMismatchAllowed(el, 1)) logMismatchError();
-						const cur = next;
-						next = next.nextSibling;
-						remove(cur);
-					}
-				} else if (shapeFlag & 8) {
-					let clientText = vnode.children;
-					if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) clientText = clientText.slice(1);
-					if (el.textContent !== clientText) {
-						if (!isMismatchAllowed(el, 0)) logMismatchError();
-						el.textContent = vnode.children;
-					}
-				}
-				if (props) {
-					if (forcePatch || !optimized || patchFlag & 48) {
-						const isCustomElement = el.tagName.includes("-");
-						for (const key in props) if (forcePatch && (key.endsWith("value") || key === "indeterminate") || shared.isOn(key) && !shared.isReservedProp(key) || key[0] === "." || isCustomElement) patchProp(el, key, null, props[key], void 0, parentComponent);
-					} else if (props.onClick) patchProp(el, "onClick", null, props.onClick, void 0, parentComponent);
-					else if (patchFlag & 4 && reactivity.isReactive(props.style)) for (const key in props.style) props.style[key];
-				}
-				let vnodeHooks;
-				if (vnodeHooks = props && props.onVnodeBeforeMount) invokeVNodeHook(vnodeHooks, parentComponent, vnode);
-				if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
-				if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) queueEffectWithSuspense(() => {
-					vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
-					needCallTransitionHooks && transition.enter(el);
-					dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
-				}, parentSuspense);
-			}
-			return el.nextSibling;
-		};
-		const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
-			optimized = optimized || !!parentVNode.dynamicChildren;
-			const children = parentVNode.children;
-			const l = children.length;
-			for (let i = 0; i < l; i++) {
-				const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
-				const isText = vnode.type === Text;
-				if (node) {
-					if (isText && !optimized) {
-						if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) {
-							insert(createText(node.data.slice(vnode.children.length)), container, nextSibling(node));
-							node.data = vnode.children;
-						}
-					}
-					node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
-				} else if (isText && !vnode.children) insert(vnode.el = createText(""), container);
-				else {
-					if (!isMismatchAllowed(container, 1)) logMismatchError();
-					patch(null, vnode, container, null, parentComponent, parentSuspense, getContainerType(container), slotScopeIds);
-				}
-			}
-			return node;
-		};
-		const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
-			const { slotScopeIds: fragmentSlotScopeIds } = vnode;
-			if (fragmentSlotScopeIds) slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
-			const container = parentNode(node);
-			const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized);
-			if (next && isComment(next) && next.data === "]") return nextSibling(vnode.anchor = next);
-			else {
-				logMismatchError();
-				insert(vnode.anchor = createComment(`]`), container, next);
-				return next;
-			}
-		};
-		const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
-			if (!isMismatchAllowed(node.parentElement, 1)) logMismatchError();
-			vnode.el = null;
-			if (isFragment) {
-				const end = locateClosingAnchor(node);
-				while (true) {
-					const next2 = nextSibling(node);
-					if (next2 && next2 !== end) remove(next2);
-					else break;
-				}
-			}
-			const next = nextSibling(node);
-			const container = parentNode(node);
-			remove(node);
-			patch(null, vnode, container, next, parentComponent, parentSuspense, getContainerType(container), slotScopeIds);
-			if (parentComponent) {
-				parentComponent.vnode.el = vnode.el;
-				updateHOCHostEl(parentComponent, vnode.el);
-			}
-			return next;
-		};
-		const locateClosingAnchor = (node, open = "[", close = "]") => {
-			let match = 0;
-			while (node) {
-				node = nextSibling(node);
-				if (node && isComment(node)) {
-					if (node.data === open) match++;
-					if (node.data === close) if (match === 0) return nextSibling(node);
-					else match--;
-				}
-			}
-			return node;
-		};
-		const replaceNode = (newNode, oldNode, parentComponent) => {
-			const parentNode2 = oldNode.parentNode;
-			if (parentNode2) parentNode2.replaceChild(newNode, oldNode);
-			let parent = parentComponent;
-			while (parent) {
-				if (parent.vnode.el === oldNode) parent.vnode.el = parent.subTree.el = newNode;
-				parent = parent.parent;
-			}
-		};
-		const isTemplateNode = (node) => {
-			return node.nodeType === 1 && node.tagName === "TEMPLATE";
-		};
-		return [hydrate, hydrateNode];
-	}
-	const allowMismatchAttr = "data-allow-mismatch";
-	const MismatchTypeString = {
-		[0]: "text",
-		[1]: "children",
-		[2]: "class",
-		[3]: "style",
-		[4]: "attribute"
-	};
-	function isMismatchAllowed(el, allowedType) {
-		if (allowedType === 0 || allowedType === 1) while (el && !el.hasAttribute(allowMismatchAttr)) el = el.parentElement;
-		const allowedAttr = el && el.getAttribute(allowMismatchAttr);
-		if (allowedAttr == null) return false;
-		else if (allowedAttr === "") return true;
-		else {
-			const list = allowedAttr.split(",");
-			if (allowedType === 0 && list.includes("children")) return true;
-			return list.includes(MismatchTypeString[allowedType]);
-		}
-	}
-	const requestIdleCallback = shared.getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
-	const cancelIdleCallback = shared.getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
-	const hydrateOnIdle = (timeout = 1e4) => (hydrate) => {
-		const id = requestIdleCallback(hydrate, { timeout });
-		return () => cancelIdleCallback(id);
-	};
-	function elementIsVisibleInViewport(el) {
-		const { top, left, bottom, right } = el.getBoundingClientRect();
-		const { innerHeight, innerWidth } = window;
-		return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth);
-	}
-	const hydrateOnVisible = (opts) => (hydrate, forEach) => {
-		const ob = new IntersectionObserver((entries) => {
-			for (const e of entries) {
-				if (!e.isIntersecting) continue;
-				ob.disconnect();
-				hydrate();
-				break;
-			}
-		}, opts);
-		forEach((el) => {
-			if (!(el instanceof Element)) return;
-			if (elementIsVisibleInViewport(el)) {
-				hydrate();
-				ob.disconnect();
-				return false;
-			}
-			ob.observe(el);
-		});
-		return () => ob.disconnect();
-	};
-	const hydrateOnMediaQuery = (query) => (hydrate) => {
-		if (query) {
-			const mql = matchMedia(query);
-			if (mql.matches) hydrate();
-			else {
-				mql.addEventListener("change", hydrate, { once: true });
-				return () => mql.removeEventListener("change", hydrate);
-			}
-		}
-	};
-	const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
-		if (shared.isString(interactions)) interactions = [interactions];
-		let hasHydrated = false;
-		const doHydrate = (e) => {
-			if (!hasHydrated) {
-				hasHydrated = true;
-				teardown();
-				hydrate();
-				e.target.dispatchEvent(new e.constructor(e.type, e));
-			}
-		};
-		const teardown = () => {
-			forEach((el) => {
-				for (const i of interactions) el.removeEventListener(i, doHydrate);
-			});
-		};
-		forEach((el) => {
-			for (const i of interactions) el.addEventListener(i, doHydrate, { once: true });
-		});
-		return teardown;
-	};
-	function forEachElement(node, cb) {
-		if (isComment(node) && node.data === "[") {
-			let depth = 1;
-			let next = node.nextSibling;
-			while (next) {
-				if (next.nodeType === 1) {
-					if (cb(next) === false) break;
-				} else if (isComment(next)) {
-					if (next.data === "]") {
-						if (--depth === 0) break;
-					} else if (next.data === "[") depth++;
-				}
-				next = next.nextSibling;
-			}
-		} else cb(node);
-	}
-	const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
-	/* @__NO_SIDE_EFFECTS__ */
-	function defineAsyncComponent(source) {
-		if (shared.isFunction(source)) source = { loader: source };
-		const { loader, loadingComponent, errorComponent, delay = 200, hydrate: hydrateStrategy, timeout, suspensible = true, onError: userOnError } = source;
-		let pendingRequest = null;
-		let resolvedComp;
-		let retries = 0;
-		const retry = () => {
-			retries++;
-			pendingRequest = null;
-			return load();
-		};
-		const load = () => {
-			let thisRequest;
-			return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
-				err = err instanceof Error ? err : new Error(String(err));
-				if (userOnError) return new Promise((resolve$1, reject) => {
-					const userRetry = () => resolve$1(retry());
-					const userFail = () => reject(err);
-					userOnError(err, userRetry, userFail, retries + 1);
-				});
-				else throw err;
-			}).then((comp) => {
-				if (thisRequest !== pendingRequest && pendingRequest) return pendingRequest;
-				if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) comp = comp.default;
-				resolvedComp = comp;
-				return comp;
-			}));
-		};
-		return /* @__PURE__ */ defineComponent({
-			name: "AsyncComponentWrapper",
-			__asyncLoader: load,
-			__asyncHydrate(el, instance, hydrate) {
-				let patched = false;
-				(instance.bu || (instance.bu = [])).push(() => patched = true);
-				const performHydrate = () => {
-					if (patched) return;
-					hydrate();
-				};
-				const doHydrate = hydrateStrategy ? () => {
-					const teardown = hydrateStrategy(performHydrate, (cb) => forEachElement(el, cb));
-					if (teardown) (instance.bum || (instance.bum = [])).push(teardown);
-				} : performHydrate;
-				if (resolvedComp) doHydrate();
-				else load().then(() => !instance.isUnmounted && doHydrate());
-			},
-			get __asyncResolved() {
-				return resolvedComp;
-			},
-			setup() {
-				const instance = currentInstance;
-				markAsyncBoundary(instance);
-				if (resolvedComp) return () => createInnerComp(resolvedComp, instance);
-				const onError = (err) => {
-					pendingRequest = null;
-					handleError(err, instance, 13, !errorComponent);
-				};
-				if (suspensible && instance.suspense || isInSSRComponentSetup) return load().then((comp) => {
-					return () => createInnerComp(comp, instance);
-				}).catch((err) => {
-					onError(err);
-					return () => errorComponent ? createVNode(errorComponent, { error: err }) : null;
-				});
-				const loaded = reactivity.ref(false);
-				const error = reactivity.ref();
-				const delayed = reactivity.ref(!!delay);
-				if (delay) setTimeout(() => {
-					delayed.value = false;
-				}, delay);
-				if (timeout != null) setTimeout(() => {
-					if (!loaded.value && !error.value) {
-						const err = /* @__PURE__ */ new Error(`Async component timed out after ${timeout}ms.`);
-						onError(err);
-						error.value = err;
-					}
-				}, timeout);
-				load().then(() => {
-					loaded.value = true;
-					if (instance.parent && isKeepAlive(instance.parent.vnode)) instance.parent.update();
-				}).catch((err) => {
-					onError(err);
-					error.value = err;
-				});
-				return () => {
-					if (loaded.value && resolvedComp) return createInnerComp(resolvedComp, instance);
-					else if (error.value && errorComponent) return createVNode(errorComponent, { error: error.value });
-					else if (loadingComponent && !delayed.value) return createVNode(loadingComponent);
-				};
-			}
-		});
-	}
-	function createInnerComp(comp, parent) {
-		const { ref: ref2, props, children, ce } = parent.vnode;
-		const vnode = createVNode(comp, props, children);
-		vnode.ref = ref2;
-		vnode.ce = ce;
-		delete parent.vnode.ce;
-		return vnode;
-	}
-	const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
-	const KeepAlive = {
-		name: `KeepAlive`,
-		__isKeepAlive: true,
-		props: {
-			include: [
-				String,
-				RegExp,
-				Array
-			],
-			exclude: [
-				String,
-				RegExp,
-				Array
-			],
-			max: [String, Number]
-		},
-		setup(props, { slots }) {
-			const instance = getCurrentInstance();
-			const sharedContext = instance.ctx;
-			if (!sharedContext.renderer) return () => {
-				const children = slots.default && slots.default();
-				return children && children.length === 1 ? children[0] : children;
-			};
-			const cache = /* @__PURE__ */ new Map();
-			const keys = /* @__PURE__ */ new Set();
-			let current = null;
-			const parentSuspense = instance.suspense;
-			const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext;
-			const storageContainer = createElement("div");
-			sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
-				const instance2 = vnode.component;
-				move(vnode, container, anchor, 0, parentSuspense);
-				patch(instance2.vnode, vnode, container, anchor, instance2, parentSuspense, namespace, vnode.slotScopeIds, optimized);
-				queuePostRenderEffect(() => {
-					instance2.isDeactivated = false;
-					if (instance2.a) shared.invokeArrayFns(instance2.a);
-					const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
-					if (vnodeHook) invokeVNodeHook(vnodeHook, instance2.parent, vnode);
-				}, parentSuspense);
-			};
-			sharedContext.deactivate = (vnode) => {
-				const instance2 = vnode.component;
-				invalidateMount(instance2.m);
-				invalidateMount(instance2.a);
-				move(vnode, storageContainer, null, 1, parentSuspense);
-				queuePostRenderEffect(() => {
-					if (instance2.da) shared.invokeArrayFns(instance2.da);
-					const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
-					if (vnodeHook) invokeVNodeHook(vnodeHook, instance2.parent, vnode);
-					instance2.isDeactivated = true;
-				}, parentSuspense);
-			};
-			function unmount(vnode) {
-				resetShapeFlag(vnode);
-				_unmount(vnode, instance, parentSuspense, true);
-			}
-			function pruneCache(filter) {
-				cache.forEach((vnode, key) => {
-					const name = getComponentName(vnode.type);
-					if (name && !filter(name)) pruneCacheEntry(key);
-				});
-			}
-			function pruneCacheEntry(key) {
-				const cached = cache.get(key);
-				if (cached && (!current || !isSameVNodeType(cached, current))) unmount(cached);
-				else if (current) resetShapeFlag(current);
-				cache.delete(key);
-				keys.delete(key);
-			}
-			watch(() => [props.include, props.exclude], ([include, exclude]) => {
-				include && pruneCache((name) => matches(include, name));
-				exclude && pruneCache((name) => !matches(exclude, name));
-			}, {
-				flush: "post",
-				deep: true
-			});
-			let pendingCacheKey = null;
-			const cacheSubtree = () => {
-				if (pendingCacheKey != null) if (isSuspense(instance.subTree.type)) queuePostRenderEffect(() => {
-					cache.set(pendingCacheKey, getInnerChild(instance.subTree));
-				}, instance.subTree.suspense);
-				else cache.set(pendingCacheKey, getInnerChild(instance.subTree));
-			};
-			onMounted(cacheSubtree);
-			onUpdated(cacheSubtree);
-			onBeforeUnmount(() => {
-				cache.forEach((cached) => {
-					const { subTree, suspense } = instance;
-					const vnode = getInnerChild(subTree);
-					if (cached.type === vnode.type && cached.key === vnode.key) {
-						resetShapeFlag(vnode);
-						const da = vnode.component.da;
-						da && queuePostRenderEffect(da, suspense);
-						return;
-					}
-					unmount(cached);
-				});
-			});
-			return () => {
-				pendingCacheKey = null;
-				if (!slots.default) return current = null;
-				const children = slots.default();
-				const rawVNode = children[0];
-				if (children.length > 1) {
-					current = null;
-					return children;
-				} else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
-					current = null;
-					return rawVNode;
-				}
-				let vnode = getInnerChild(rawVNode);
-				if (vnode.type === Comment) {
-					current = null;
-					return vnode;
-				}
-				const comp = vnode.type;
-				const name = getComponentName(isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp);
-				const { include, exclude, max } = props;
-				if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
-					vnode.shapeFlag &= -257;
-					current = vnode;
-					return rawVNode;
-				}
-				const key = vnode.key == null ? comp : vnode.key;
-				const cachedVNode = cache.get(key);
-				if (vnode.el) {
-					vnode = cloneVNode(vnode);
-					if (rawVNode.shapeFlag & 128) rawVNode.ssContent = vnode;
-				}
-				pendingCacheKey = key;
-				if (cachedVNode) {
-					vnode.el = cachedVNode.el;
-					vnode.component = cachedVNode.component;
-					if (vnode.transition) setTransitionHooks(vnode, vnode.transition);
-					vnode.shapeFlag |= 512;
-					keys.delete(key);
-					keys.add(key);
-				} else {
-					keys.add(key);
-					if (max && keys.size > parseInt(max, 10)) pruneCacheEntry(keys.values().next().value);
-				}
-				vnode.shapeFlag |= 256;
-				current = vnode;
-				return isSuspense(rawVNode.type) ? rawVNode : vnode;
-			};
-		}
-	};
-	function matches(pattern, name) {
-		if (shared.isArray(pattern)) return pattern.some((p) => matches(p, name));
-		else if (shared.isString(pattern)) return pattern.split(",").includes(name);
-		else if (shared.isRegExp(pattern)) {
-			pattern.lastIndex = 0;
-			return pattern.test(name);
-		}
-		return false;
-	}
-	function onActivated(hook, target) {
-		registerKeepAliveHook(hook, "a", target);
-	}
-	function onDeactivated(hook, target) {
-		registerKeepAliveHook(hook, "da", target);
-	}
-	function registerKeepAliveHook(hook, type, target = currentInstance) {
-		const wrappedHook = hook.__wdc || (hook.__wdc = () => {
-			let current = target;
-			while (current) {
-				if (current.isDeactivated) return;
-				current = current.parent;
-			}
-			return hook();
-		});
-		injectHook(type, wrappedHook, target);
-		if (target) {
-			let current = target.parent;
-			while (current && current.parent) {
-				if (isKeepAlive(current.parent.vnode)) injectToKeepAliveRoot(wrappedHook, type, target, current);
-				current = current.parent;
-			}
-		}
-	}
-	function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
-		const injected = injectHook(type, hook, keepAliveRoot, true);
-		onUnmounted(() => {
-			shared.remove(keepAliveRoot[type], injected);
-		}, target);
-	}
-	function resetShapeFlag(vnode) {
-		vnode.shapeFlag &= -257;
-		vnode.shapeFlag &= -513;
-	}
-	function getInnerChild(vnode) {
-		return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
-	}
-	function injectHook(type, hook, target = currentInstance, prepend = false) {
-		if (target) {
-			const hooks = target[type] || (target[type] = []);
-			const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
-				reactivity.pauseTracking();
-				const reset = setCurrentInstance(target);
-				const res = callWithAsyncErrorHandling(hook, target, type, args);
-				reset();
-				reactivity.resetTracking();
-				return res;
-			});
-			if (prepend) hooks.unshift(wrappedHook);
-			else hooks.push(wrappedHook);
-			return wrappedHook;
-		}
-	}
-	const createHook = (lifecycle) => (hook, target = currentInstance) => {
-		if (!isInSSRComponentSetup || lifecycle === "sp") injectHook(lifecycle, (...args) => hook(...args), target);
-	};
-	const onBeforeMount = createHook("bm");
-	const onMounted = createHook("m");
-	const onBeforeUpdate = createHook("bu");
-	const onUpdated = createHook("u");
-	const onBeforeUnmount = createHook("bum");
-	const onUnmounted = createHook("um");
-	const onServerPrefetch = createHook("sp");
-	const onRenderTriggered = createHook("rtg");
-	const onRenderTracked = createHook("rtc");
-	function onErrorCaptured(hook, target = currentInstance) {
-		injectHook("ec", hook, target);
-	}
-	const COMPONENTS = "components";
-	const DIRECTIVES = "directives";
-	function resolveComponent(name, maybeSelfReference) {
-		return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
-	}
-	const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
-	function resolveDynamicComponent(component) {
-		if (shared.isString(component)) return resolveAsset(COMPONENTS, component, false) || component;
-		else return component || NULL_DYNAMIC_COMPONENT;
-	}
-	function resolveDirective(name) {
-		return resolveAsset(DIRECTIVES, name);
-	}
-	function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
-		const instance = currentRenderingInstance || currentInstance;
-		if (instance) {
-			const Component = instance.type;
-			if (type === COMPONENTS) {
-				const selfName = getComponentName(Component, false);
-				if (selfName && (selfName === name || selfName === shared.camelize(name) || selfName === shared.capitalize(shared.camelize(name)))) return Component;
-			}
-			const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name);
-			if (!res && maybeSelfReference) return Component;
-			return res;
-		}
-	}
-	function resolve(registry, name) {
-		return registry && (registry[name] || registry[shared.camelize(name)] || registry[shared.capitalize(shared.camelize(name))]);
-	}
-	function renderList(source, renderItem, cache, index) {
-		let ret;
-		const cached = cache && cache[index];
-		const sourceIsArray = shared.isArray(source);
-		if (sourceIsArray || shared.isString(source)) {
-			const sourceIsReactiveArray = sourceIsArray && reactivity.isReactive(source);
-			let needsWrap = false;
-			let isReadonlySource = false;
-			if (sourceIsReactiveArray) {
-				needsWrap = !reactivity.isShallow(source);
-				isReadonlySource = reactivity.isReadonly(source);
-				source = reactivity.shallowReadArray(source);
-			}
-			ret = new Array(source.length);
-			for (let i = 0, l = source.length; i < l; i++) ret[i] = renderItem(needsWrap ? isReadonlySource ? reactivity.toReadonly(reactivity.toReactive(source[i])) : reactivity.toReactive(source[i]) : source[i], i, void 0, cached && cached[i]);
-		} else if (typeof source === "number") {
-			ret = new Array(source);
-			for (let i = 0; i < source; i++) ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
-		} else if (shared.isObject(source)) if (source[Symbol.iterator]) ret = Array.from(source, (item, i) => renderItem(item, i, void 0, cached && cached[i]));
-		else {
-			const keys = Object.keys(source);
-			ret = new Array(keys.length);
-			for (let i = 0, l = keys.length; i < l; i++) {
-				const key = keys[i];
-				ret[i] = renderItem(source[key], key, i, cached && cached[i]);
-			}
-		}
-		else ret = [];
-		if (cache) cache[index] = ret;
-		return ret;
-	}
-	function createSlots(slots, dynamicSlots) {
-		for (let i = 0; i < dynamicSlots.length; i++) {
-			const slot = dynamicSlots[i];
-			if (shared.isArray(slot)) for (let j = 0; j < slot.length; j++) slots[slot[j].name] = slot[j].fn;
-			else if (slot) slots[slot.name] = slot.key ? (...args) => {
-				const res = slot.fn(...args);
-				if (res) res.key = slot.key;
-				return res;
-			} : slot.fn;
-		}
-		return slots;
-	}
-	function renderSlot(slots, name, props = {}, fallback, noSlotted) {
-		if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
-			const hasProps = Object.keys(props).length > 0;
-			if (name !== "default") props.name = name;
-			return openBlock(), createBlock(Fragment, null, [createVNode("slot", props, fallback && fallback())], hasProps ? -2 : 64);
-		}
-		let slot = slots[name];
-		if (slot && slot._c) slot._d = false;
-		openBlock();
-		const validSlotContent = slot && ensureValidVNode(slot(props));
-		const slotKey = props.key || validSlotContent && validSlotContent.key;
-		const rendered = createBlock(Fragment, { key: (slotKey && !shared.isSymbol(slotKey) ? slotKey : `_${name}`) + (!validSlotContent && fallback ? "_fb" : "") }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 ? 64 : -2);
-		if (!noSlotted && rendered.scopeId) rendered.slotScopeIds = [rendered.scopeId + "-s"];
-		if (slot && slot._c) slot._d = true;
-		return rendered;
-	}
-	function ensureValidVNode(vnodes) {
-		return vnodes.some((child) => {
-			if (!isVNode(child)) return true;
-			if (child.type === Comment) return false;
-			if (child.type === Fragment && !ensureValidVNode(child.children)) return false;
-			return true;
-		}) ? vnodes : null;
-	}
-	function toHandlers(obj, preserveCaseIfNecessary) {
-		const ret = {};
-		for (const key in obj) ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : shared.toHandlerKey(key)] = obj[key];
-		return ret;
-	}
-	const getPublicInstance = (i) => {
-		if (!i) return null;
-		if (isStatefulComponent(i)) return getComponentPublicInstance(i);
-		return getPublicInstance(i.parent);
-	};
-	const publicPropertiesMap = /* @__PURE__ */ shared.extend(/* @__PURE__ */ Object.create(null), {
-		$: (i) => i,
-		$el: (i) => i.vnode.el,
-		$data: (i) => i.data,
-		$props: (i) => i.props,
-		$attrs: (i) => i.attrs,
-		$slots: (i) => i.slots,
-		$refs: (i) => i.refs,
-		$parent: (i) => getPublicInstance(i.parent),
-		$root: (i) => getPublicInstance(i.root),
-		$host: (i) => i.ce,
-		$emit: (i) => i.emit,
-		$options: (i) => resolveMergedOptions(i),
-		$forceUpdate: (i) => i.f || (i.f = () => {
-			queueJob(i.update);
-		}),
-		$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
-		$watch: (i) => instanceWatch.bind(i)
-	});
-	const hasSetupBinding = (state, key) => state !== shared.EMPTY_OBJ && !state.__isScriptSetup && shared.hasOwn(state, key);
-	const PublicInstanceProxyHandlers = {
-		get({ _: instance }, key) {
-			if (key === "__v_skip") return true;
-			const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
-			let normalizedProps;
-			if (key[0] !== "$") {
-				const n = accessCache[key];
-				if (n !== void 0) switch (n) {
-					case 1: return setupState[key];
-					case 2: return data[key];
-					case 4: return ctx[key];
-					case 3: return props[key];
-				}
-				else if (hasSetupBinding(setupState, key)) {
-					accessCache[key] = 1;
-					return setupState[key];
-				} else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
-					accessCache[key] = 2;
-					return data[key];
-				} else if ((normalizedProps = instance.propsOptions[0]) && shared.hasOwn(normalizedProps, key)) {
-					accessCache[key] = 3;
-					return props[key];
-				} else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
-					accessCache[key] = 4;
-					return ctx[key];
-				} else if (shouldCacheAccess) accessCache[key] = 0;
-			}
-			const publicGetter = publicPropertiesMap[key];
-			let cssModule, globalProperties;
-			if (publicGetter) {
-				if (key === "$attrs") reactivity.track(instance.attrs, "get", "");
-				return publicGetter(instance);
-			} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) return cssModule;
-			else if (ctx !== shared.EMPTY_OBJ && shared.hasOwn(ctx, key)) {
-				accessCache[key] = 4;
-				return ctx[key];
-			} else if (globalProperties = appContext.config.globalProperties, shared.hasOwn(globalProperties, key)) return globalProperties[key];
-		},
-		set({ _: instance }, key, value) {
-			const { data, setupState, ctx } = instance;
-			if (hasSetupBinding(setupState, key)) {
-				setupState[key] = value;
-				return true;
-			} else if (data !== shared.EMPTY_OBJ && shared.hasOwn(data, key)) {
-				data[key] = value;
-				return true;
-			} else if (shared.hasOwn(instance.props, key)) return false;
-			if (key[0] === "$" && key.slice(1) in instance) return false;
-			else ctx[key] = value;
-			return true;
-		},
-		has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions, type } }, key) {
-			let normalizedProps, cssModules;
-			return !!(accessCache[key] || data !== shared.EMPTY_OBJ && key[0] !== "$" && shared.hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && shared.hasOwn(normalizedProps, key) || shared.hasOwn(ctx, key) || shared.hasOwn(publicPropertiesMap, key) || shared.hasOwn(appContext.config.globalProperties, key) || (cssModules = type.__cssModules) && cssModules[key]);
-		},
-		defineProperty(target, key, descriptor) {
-			if (descriptor.get != null) target._.accessCache[key] = 0;
-			else if (shared.hasOwn(descriptor, "value")) this.set(target, key, descriptor.value, null);
-			return Reflect.defineProperty(target, key, descriptor);
-		}
-	};
-	const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ shared.extend({}, PublicInstanceProxyHandlers, {
-		get(target, key) {
-			if (key === Symbol.unscopables) return;
-			return PublicInstanceProxyHandlers.get(target, key, target);
-		},
-		has(_, key) {
-			return key[0] !== "_" && !shared.isGloballyAllowed(key);
-		}
-	});
-	function defineProps() {
-		return null;
-	}
-	function defineEmits() {
-		return null;
-	}
-	function defineExpose(exposed) {}
-	function defineOptions(options) {}
-	function defineSlots() {
-		return null;
-	}
-	function defineModel() {}
-	function withDefaults(props, defaults) {
-		return null;
-	}
-	function useSlots() {
-		return getContext().slots;
-	}
-	function useAttrs() {
-		return getContext().attrs;
-	}
-	function getContext(calledFunctionName) {
-		const i = getCurrentInstance();
-		return i.setupContext || (i.setupContext = createSetupContext(i));
-	}
-	function normalizePropsOrEmits(props) {
-		return shared.isArray(props) ? props.reduce((normalized, p) => (normalized[p] = null, normalized), {}) : props;
-	}
-	function mergeDefaults(raw, defaults) {
-		const props = normalizePropsOrEmits(raw);
-		for (const key in defaults) {
-			if (key.startsWith("__skip")) continue;
-			let opt = props[key];
-			if (opt) if (shared.isArray(opt) || shared.isFunction(opt)) opt = props[key] = {
-				type: opt,
-				default: defaults[key]
-			};
-			else opt.default = defaults[key];
-			else if (opt === null) opt = props[key] = { default: defaults[key] };
-			if (opt && defaults[`__skip_${key}`]) opt.skipFactory = true;
-		}
-		return props;
-	}
-	function mergeModels(a, b) {
-		if (!a || !b) return a || b;
-		if (shared.isArray(a) && shared.isArray(b)) return a.concat(b);
-		return shared.extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
-	}
-	function createPropsRestProxy(props, excludedKeys) {
-		const ret = {};
-		for (const key in props) if (!excludedKeys.includes(key)) Object.defineProperty(ret, key, {
-			enumerable: true,
-			get: () => props[key]
-		});
-		return ret;
-	}
-	function withAsyncContext(getAwaitable) {
-		const ctx = getCurrentInstance();
-		let awaitable = getAwaitable();
-		unsetCurrentInstance();
-		if (shared.isPromise(awaitable)) awaitable = awaitable.catch((e) => {
-			setCurrentInstance(ctx);
-			throw e;
-		});
-		return [awaitable, () => setCurrentInstance(ctx)];
-	}
-	let shouldCacheAccess = true;
-	function applyOptions(instance) {
-		const options = resolveMergedOptions(instance);
-		const publicThis = instance.proxy;
-		const ctx = instance.ctx;
-		shouldCacheAccess = false;
-		if (options.beforeCreate) callHook(options.beforeCreate, instance, "bc");
-		const { data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, expose, inheritAttrs, components, directives, filters } = options;
-		const checkDuplicateProperties = null;
-		if (injectOptions) resolveInjections(injectOptions, ctx, checkDuplicateProperties);
-		if (methods) for (const key in methods) {
-			const methodHandler = methods[key];
-			if (shared.isFunction(methodHandler)) ctx[key] = methodHandler.bind(publicThis);
-		}
-		if (dataOptions) {
-			const data = dataOptions.call(publicThis, publicThis);
-			if (!shared.isObject(data));
-			else instance.data = reactivity.reactive(data);
-		}
-		shouldCacheAccess = true;
-		if (computedOptions) for (const key in computedOptions) {
-			const opt = computedOptions[key];
-			const c = computed({
-				get: shared.isFunction(opt) ? opt.bind(publicThis, publicThis) : shared.isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : shared.NOOP,
-				set: !shared.isFunction(opt) && shared.isFunction(opt.set) ? opt.set.bind(publicThis) : shared.NOOP
-			});
-			Object.defineProperty(ctx, key, {
-				enumerable: true,
-				configurable: true,
-				get: () => c.value,
-				set: (v) => c.value = v
-			});
-		}
-		if (watchOptions) for (const key in watchOptions) createWatcher(watchOptions[key], ctx, publicThis, key);
-		if (provideOptions) {
-			const provides = shared.isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
-			Reflect.ownKeys(provides).forEach((key) => {
-				provide(key, provides[key]);
-			});
-		}
-		if (created) callHook(created, instance, "c");
-		function registerLifecycleHook(register, hook) {
-			if (shared.isArray(hook)) hook.forEach((_hook) => register(_hook.bind(publicThis)));
-			else if (hook) register(hook.bind(publicThis));
-		}
-		registerLifecycleHook(onBeforeMount, beforeMount);
-		registerLifecycleHook(onMounted, mounted);
-		registerLifecycleHook(onBeforeUpdate, beforeUpdate);
-		registerLifecycleHook(onUpdated, updated);
-		registerLifecycleHook(onActivated, activated);
-		registerLifecycleHook(onDeactivated, deactivated);
-		registerLifecycleHook(onErrorCaptured, errorCaptured);
-		registerLifecycleHook(onRenderTracked, renderTracked);
-		registerLifecycleHook(onRenderTriggered, renderTriggered);
-		registerLifecycleHook(onBeforeUnmount, beforeUnmount);
-		registerLifecycleHook(onUnmounted, unmounted);
-		registerLifecycleHook(onServerPrefetch, serverPrefetch);
-		if (shared.isArray(expose)) {
-			if (expose.length) {
-				const exposed = instance.exposed || (instance.exposed = {});
-				expose.forEach((key) => {
-					Object.defineProperty(exposed, key, {
-						get: () => publicThis[key],
-						set: (val) => publicThis[key] = val,
-						enumerable: true
-					});
-				});
-			} else if (!instance.exposed) instance.exposed = {};
-		}
-		if (render && instance.render === shared.NOOP) instance.render = render;
-		if (inheritAttrs != null) instance.inheritAttrs = inheritAttrs;
-		if (components) instance.components = components;
-		if (directives) instance.directives = directives;
-		if (serverPrefetch) markAsyncBoundary(instance);
-	}
-	function resolveInjections(injectOptions, ctx, checkDuplicateProperties = shared.NOOP) {
-		if (shared.isArray(injectOptions)) injectOptions = normalizeInject(injectOptions);
-		for (const key in injectOptions) {
-			const opt = injectOptions[key];
-			let injected;
-			if (shared.isObject(opt)) if ("default" in opt) injected = inject(opt.from || key, opt.default, true);
-			else injected = inject(opt.from || key);
-			else injected = inject(opt);
-			if (reactivity.isRef(injected)) Object.defineProperty(ctx, key, {
-				enumerable: true,
-				configurable: true,
-				get: () => injected.value,
-				set: (v) => injected.value = v
-			});
-			else ctx[key] = injected;
-		}
-	}
-	function callHook(hook, instance, type) {
-		callWithAsyncErrorHandling(shared.isArray(hook) ? hook.map((h$1) => h$1.bind(instance.proxy)) : hook.bind(instance.proxy), instance, type);
-	}
-	function createWatcher(raw, ctx, publicThis, key) {
-		let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
-		if (shared.isString(raw)) {
-			const handler = ctx[raw];
-			if (shared.isFunction(handler)) watch(getter, handler);
-		} else if (shared.isFunction(raw)) watch(getter, raw.bind(publicThis));
-		else if (shared.isObject(raw)) if (shared.isArray(raw)) raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
-		else {
-			const handler = shared.isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
-			if (shared.isFunction(handler)) watch(getter, handler, raw);
-		}
-	}
-	function resolveMergedOptions(instance) {
-		const base = instance.type;
-		const { mixins, extends: extendsOptions } = base;
-		const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext;
-		const cached = cache.get(base);
-		let resolved;
-		if (cached) resolved = cached;
-		else if (!globalMixins.length && !mixins && !extendsOptions) resolved = base;
-		else {
-			resolved = {};
-			if (globalMixins.length) globalMixins.forEach((m) => mergeOptions(resolved, m, optionMergeStrategies, true));
-			mergeOptions(resolved, base, optionMergeStrategies);
-		}
-		if (shared.isObject(base)) cache.set(base, resolved);
-		return resolved;
-	}
-	function mergeOptions(to, from, strats, asMixin = false) {
-		const { mixins, extends: extendsOptions } = from;
-		if (extendsOptions) mergeOptions(to, extendsOptions, strats, true);
-		if (mixins) mixins.forEach((m) => mergeOptions(to, m, strats, true));
-		for (const key in from) if (asMixin && key === "expose");
-		else {
-			const strat = internalOptionMergeStrats[key] || strats && strats[key];
-			to[key] = strat ? strat(to[key], from[key]) : from[key];
-		}
-		return to;
-	}
-	const internalOptionMergeStrats = {
-		data: mergeDataFn,
-		props: mergeEmitsOrPropsOptions,
-		emits: mergeEmitsOrPropsOptions,
-		methods: mergeObjectOptions,
-		computed: mergeObjectOptions,
-		beforeCreate: mergeAsArray,
-		created: mergeAsArray,
-		beforeMount: mergeAsArray,
-		mounted: mergeAsArray,
-		beforeUpdate: mergeAsArray,
-		updated: mergeAsArray,
-		beforeDestroy: mergeAsArray,
-		beforeUnmount: mergeAsArray,
-		destroyed: mergeAsArray,
-		unmounted: mergeAsArray,
-		activated: mergeAsArray,
-		deactivated: mergeAsArray,
-		errorCaptured: mergeAsArray,
-		serverPrefetch: mergeAsArray,
-		components: mergeObjectOptions,
-		directives: mergeObjectOptions,
-		watch: mergeWatchOptions,
-		provide: mergeDataFn,
-		inject: mergeInject
-	};
-	function mergeDataFn(to, from) {
-		if (!from) return to;
-		if (!to) return from;
-		return function mergedDataFn() {
-			return shared.extend(shared.isFunction(to) ? to.call(this, this) : to, shared.isFunction(from) ? from.call(this, this) : from);
-		};
-	}
-	function mergeInject(to, from) {
-		return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
-	}
-	function normalizeInject(raw) {
-		if (shared.isArray(raw)) {
-			const res = {};
-			for (let i = 0; i < raw.length; i++) res[raw[i]] = raw[i];
-			return res;
-		}
-		return raw;
-	}
-	function mergeAsArray(to, from) {
-		return to ? [...new Set([].concat(to, from))] : from;
-	}
-	function mergeObjectOptions(to, from) {
-		return to ? shared.extend(/* @__PURE__ */ Object.create(null), to, from) : from;
-	}
-	function mergeEmitsOrPropsOptions(to, from) {
-		if (to) {
-			if (shared.isArray(to) && shared.isArray(from)) return [.../* @__PURE__ */ new Set([...to, ...from])];
-			return shared.extend(/* @__PURE__ */ Object.create(null), normalizePropsOrEmits(to), normalizePropsOrEmits(from != null ? from : {}));
-		} else return from;
-	}
-	function mergeWatchOptions(to, from) {
-		if (!to) return from;
-		if (!from) return to;
-		const merged = shared.extend(/* @__PURE__ */ Object.create(null), to);
-		for (const key in from) merged[key] = mergeAsArray(to[key], from[key]);
-		return merged;
-	}
-	function createAppContext() {
-		return {
-			app: null,
-			config: {
-				isNativeTag: shared.NO,
-				performance: false,
-				globalProperties: {},
-				optionMergeStrategies: {},
-				errorHandler: void 0,
-				warnHandler: void 0,
-				compilerOptions: {}
-			},
-			mixins: [],
-			components: {},
-			directives: {},
-			provides: /* @__PURE__ */ Object.create(null),
-			optionsCache: /* @__PURE__ */ new WeakMap(),
-			propsCache: /* @__PURE__ */ new WeakMap(),
-			emitsCache: /* @__PURE__ */ new WeakMap()
-		};
-	}
-	let uid$1 = 0;
-	function createAppAPI(render, hydrate) {
-		return function createApp(rootComponent, rootProps = null) {
-			if (!shared.isFunction(rootComponent)) rootComponent = shared.extend({}, rootComponent);
-			if (rootProps != null && !shared.isObject(rootProps)) rootProps = null;
-			const context = createAppContext();
-			const installedPlugins = /* @__PURE__ */ new WeakSet();
-			const pluginCleanupFns = [];
-			let isMounted = false;
-			const app = context.app = {
-				_uid: uid$1++,
-				_component: rootComponent,
-				_props: rootProps,
-				_container: null,
-				_context: context,
-				_instance: null,
-				version,
-				get config() {
-					return context.config;
-				},
-				set config(v) {},
-				use(plugin, ...options) {
-					if (installedPlugins.has(plugin));
-					else if (plugin && shared.isFunction(plugin.install)) {
-						installedPlugins.add(plugin);
-						plugin.install(app, ...options);
-					} else if (shared.isFunction(plugin)) {
-						installedPlugins.add(plugin);
-						plugin(app, ...options);
-					}
-					return app;
-				},
-				mixin(mixin) {
-					if (!context.mixins.includes(mixin)) context.mixins.push(mixin);
-					return app;
-				},
-				component(name, component) {
-					if (!component) return context.components[name];
-					context.components[name] = component;
-					return app;
-				},
-				directive(name, directive) {
-					if (!directive) return context.directives[name];
-					context.directives[name] = directive;
-					return app;
-				},
-				mount(rootContainer, isHydrate, namespace) {
-					if (!isMounted) {
-						const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
-						vnode.appContext = context;
-						if (namespace === true) namespace = "svg";
-						else if (namespace === false) namespace = void 0;
-						if (isHydrate && hydrate) hydrate(vnode, rootContainer);
-						else render(vnode, rootContainer, namespace);
-						isMounted = true;
-						app._container = rootContainer;
-						rootContainer.__vue_app__ = app;
-						return getComponentPublicInstance(vnode.component);
-					}
-				},
-				onUnmount(cleanupFn) {
-					pluginCleanupFns.push(cleanupFn);
-				},
-				unmount() {
-					if (isMounted) {
-						callWithAsyncErrorHandling(pluginCleanupFns, app._instance, 16);
-						render(null, app._container);
-						delete app._container.__vue_app__;
-					}
-				},
-				provide(key, value) {
-					context.provides[key] = value;
-					return app;
-				},
-				runWithContext(fn) {
-					const lastApp = currentApp;
-					currentApp = app;
-					try {
-						return fn();
-					} finally {
-						currentApp = lastApp;
-					}
-				}
-			};
-			return app;
-		};
-	}
-	let currentApp = null;
-	function provide(key, value) {
-		if (!currentInstance);
-		else {
-			let provides = currentInstance.provides;
-			const parentProvides = currentInstance.parent && currentInstance.parent.provides;
-			if (parentProvides === provides) provides = currentInstance.provides = Object.create(parentProvides);
-			provides[key] = value;
-		}
-	}
-	function inject(key, defaultValue, treatDefaultAsFactory = false) {
-		const instance = getCurrentInstance();
-		if (instance || currentApp) {
-			let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
-			if (provides && key in provides) return provides[key];
-			else if (arguments.length > 1) return treatDefaultAsFactory && shared.isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
-		}
-	}
-	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 (isStateful) instance.props = isSSR ? props : reactivity.shallowReactive(props);
-		else if (!instance.type.props) instance.props = attrs;
-		else instance.props = props;
-		instance.attrs = attrs;
-	}
-	function updateProps(instance, rawProps, rawPrevProps, optimized) {
-		const { props, attrs, vnode: { patchFlag } } = instance;
-		const rawCurrentProps = reactivity.toRaw(props);
-		const [options] = instance.propsOptions;
-		let hasAttrsChanged = false;
-		if ((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 (shared.hasOwn(attrs, key)) {
-						if (value !== attrs[key]) {
-							attrs[key] = value;
-							hasAttrsChanged = true;
-						}
-					} else {
-						const camelizedKey = shared.camelize(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 || !shared.hasOwn(rawProps, key) && ((kebabKey = shared.hyphenate(key)) === key || !shared.hasOwn(rawProps, kebabKey))) if (options) {
-				if (rawPrevProps && (rawPrevProps[key] !== void 0 || rawPrevProps[kebabKey] !== void 0)) props[key] = resolvePropValue(options, rawCurrentProps, key, void 0, instance, true);
-			} else delete props[key];
-			if (attrs !== rawCurrentProps) {
-				for (const key in attrs) if (!rawProps || !shared.hasOwn(rawProps, key) && true) {
-					delete attrs[key];
-					hasAttrsChanged = true;
-				}
-			}
-		}
-		if (hasAttrsChanged) reactivity.trigger(instance.attrs, "set", "");
-	}
-	function setFullProps(instance, rawProps, props, attrs) {
-		const [options, needCastKeys] = instance.propsOptions;
-		let hasAttrsChanged = false;
-		let rawCastValues;
-		if (rawProps) for (let key in rawProps) {
-			if (shared.isReservedProp(key)) continue;
-			const value = rawProps[key];
-			let camelKey;
-			if (options && shared.hasOwn(options, camelKey = shared.camelize(key))) if (!needCastKeys || !needCastKeys.includes(camelKey)) props[camelKey] = value;
-			else (rawCastValues || (rawCastValues = {}))[camelKey] = value;
-			else if (!isEmitListener(instance.emitsOptions, key)) {
-				if (!(key in attrs) || value !== attrs[key]) {
-					attrs[key] = value;
-					hasAttrsChanged = true;
-				}
-			}
-		}
-		if (needCastKeys) {
-			const rawCurrentProps = reactivity.toRaw(props);
-			const castValues = rawCastValues || shared.EMPTY_OBJ;
-			for (let i = 0; i < needCastKeys.length; i++) {
-				const key = needCastKeys[i];
-				props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !shared.hasOwn(castValues, key));
-			}
-		}
-		return hasAttrsChanged;
-	}
-	function resolvePropValue(options, props, key, value, instance, isAbsent) {
-		const opt = options[key];
-		if (opt != null) {
-			const hasDefault = shared.hasOwn(opt, "default");
-			if (hasDefault && value === void 0) {
-				const defaultValue = opt.default;
-				if (opt.type !== Function && !opt.skipFactory && shared.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 === shared.hyphenate(key))) value = true;
-			}
-		}
-		return value;
-	}
-	const mixinPropsCache = /* @__PURE__ */ new WeakMap();
-	function normalizePropsOptions(comp, appContext, asMixin = false) {
-		const cache = 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 (!shared.isFunction(comp)) {
-			const extendProps = (raw2) => {
-				hasExtends = true;
-				const [props, keys] = normalizePropsOptions(raw2, appContext, true);
-				shared.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 (!raw && !hasExtends) {
-			if (shared.isObject(comp)) cache.set(comp, shared.EMPTY_ARR);
-			return shared.EMPTY_ARR;
-		}
-		if (shared.isArray(raw)) for (let i = 0; i < raw.length; i++) {
-			const normalizedKey = shared.camelize(raw[i]);
-			if (validatePropName(normalizedKey)) normalized[normalizedKey] = shared.EMPTY_OBJ;
-		}
-		else if (raw) for (const key in raw) {
-			const normalizedKey = shared.camelize(key);
-			if (validatePropName(normalizedKey)) {
-				const opt = raw[key];
-				const prop = normalized[normalizedKey] = shared.isArray(opt) || shared.isFunction(opt) ? { type: opt } : shared.extend({}, opt);
-				const propType = prop.type;
-				let shouldCast = false;
-				let shouldCastTrue = true;
-				if (shared.isArray(propType)) for (let index = 0; index < propType.length; ++index) {
-					const type = propType[index];
-					const typeName = shared.isFunction(type) && type.name;
-					if (typeName === "Boolean") {
-						shouldCast = true;
-						break;
-					} else if (typeName === "String") shouldCastTrue = false;
-				}
-				else shouldCast = shared.isFunction(propType) && propType.name === "Boolean";
-				prop[0] = shouldCast;
-				prop[1] = shouldCastTrue;
-				if (shouldCast || shared.hasOwn(prop, "default")) needCastKeys.push(normalizedKey);
-			}
-		}
-		const res = [normalized, needCastKeys];
-		if (shared.isObject(comp)) cache.set(comp, res);
-		return res;
-	}
-	function validatePropName(key) {
-		if (key[0] !== "$" && !shared.isReservedProp(key)) return true;
-		return false;
-	}
-	const isInternalKey = (key) => key === "_" || key === "_ctx" || key === "$stable";
-	const normalizeSlotValue = (value) => shared.isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
-	const normalizeSlot = (key, rawSlot, ctx) => {
-		if (rawSlot._n) return rawSlot;
-		const normalized = withCtx((...args) => {
-			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 (shared.isFunction(value)) slots[key] = normalizeSlot(key, value, ctx);
-			else if (value != null) {
-				const normalized = normalizeSlotValue(value);
-				slots[key] = () => normalized;
-			}
-		}
-	};
-	const normalizeVNodeSlots = (instance, children) => {
-		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) shared.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 = shared.EMPTY_OBJ;
-		if (vnode.shapeFlag & 32) {
-			const type = children._;
-			if (type) 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];
-		}
-	};
-	const queuePostRenderEffect = queueEffectWithSuspense;
-	function createRenderer(options) {
-		return baseCreateRenderer(options);
-	}
-	function createHydrationRenderer(options) {
-		return baseCreateRenderer(options, createHydrationFunctions);
-	}
-	function baseCreateRenderer(options, createHydrationFns) {
-		const target = shared.getGlobalThis();
-		target.__VUE__ = true;
-		const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = shared.NOOP, insertStaticContent: hostInsertStaticContent } = options;
-		const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
-			if (n1 === n2) return;
-			if (n1 && !isSameVNodeType(n1, n2)) {
-				anchor = getNextHostNode(n1);
-				unmount(n1, parentComponent, parentSuspense, true);
-				n1 = null;
-			}
-			if (n2.patchFlag === -2) {
-				optimized = false;
-				n2.dynamicChildren = null;
-			}
-			const { type, ref, shapeFlag } = n2;
-			switch (type) {
-				case Text:
-					processText(n1, n2, container, anchor);
-					break;
-				case Comment:
-					processCommentNode(n1, n2, container, anchor);
-					break;
-				case Static:
-					if (n1 == null) mountStaticNode(n2, container, anchor, namespace);
-					break;
-				case Fragment:
-					processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-					break;
-				default: if (shapeFlag & 1) processElement(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-				else if (shapeFlag & 6) processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-				else if (shapeFlag & 64) type.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals);
-				else if (shapeFlag & 128) type.process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals);
-			}
-			if (ref != null && parentComponent) setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
-			else if (ref == null && n1 && n1.ref != null) setRef(n1.ref, null, parentSuspense, n1, true);
-		};
-		const processText = (n1, n2, container, anchor) => {
-			if (n1 == null) hostInsert(n2.el = hostCreateText(n2.children), container, anchor);
-			else {
-				const el = n2.el = n1.el;
-				if (n2.children !== n1.children) hostSetText(el, n2.children);
-			}
-		};
-		const processCommentNode = (n1, n2, container, anchor) => {
-			if (n1 == null) hostInsert(n2.el = hostCreateComment(n2.children || ""), container, anchor);
-			else n2.el = n1.el;
-		};
-		const mountStaticNode = (n2, container, anchor, namespace) => {
-			[n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, namespace, n2.el, n2.anchor);
-		};
-		const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
-			let next;
-			while (el && el !== anchor) {
-				next = hostNextSibling(el);
-				hostInsert(el, container, nextSibling);
-				el = next;
-			}
-			hostInsert(anchor, container, nextSibling);
-		};
-		const removeStaticNode = ({ el, anchor }) => {
-			let next;
-			while (el && el !== anchor) {
-				next = hostNextSibling(el);
-				hostRemove(el);
-				el = next;
-			}
-			hostRemove(anchor);
-		};
-		const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
-			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);
-		};
-		const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
-			let el;
-			let vnodeHook;
-			const { props, shapeFlag, transition, dirs } = vnode;
-			el = vnode.el = hostCreateElement(vnode.type, namespace, props && props.is, props);
-			if (shapeFlag & 8) hostSetElementText(el, vnode.children);
-			else if (shapeFlag & 16) mountChildren(vnode.children, el, null, parentComponent, parentSuspense, resolveChildrenNamespace(vnode, namespace), slotScopeIds, optimized);
-			if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "created");
-			setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
-			if (props) {
-				for (const key in props) if (key !== "value" && !shared.isReservedProp(key)) hostPatchProp(el, key, null, props[key], namespace, parentComponent);
-				if ("value" in props) hostPatchProp(el, "value", null, props.value, namespace);
-				if (vnodeHook = props.onVnodeBeforeMount) invokeVNodeHook(vnodeHook, parentComponent, vnode);
-			}
-			if (dirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
-			const needCallTransitionHooks = needTransition(parentSuspense, transition);
-			if (needCallTransitionHooks) transition.beforeEnter(el);
-			hostInsert(el, container, anchor);
-			if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) queuePostRenderEffect(() => {
-				vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
-				needCallTransitionHooks && transition.enter(el);
-				dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
-			}, parentSuspense);
-		};
-		const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
-			if (scopeId) hostSetScopeId(el, scopeId);
-			if (slotScopeIds) for (let i = 0; i < slotScopeIds.length; i++) hostSetScopeId(el, slotScopeIds[i]);
-			if (parentComponent) {
-				let subTree = parentComponent.subTree;
-				if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
-					const parentVNode = parentComponent.vnode;
-					setScopeId(el, parentVNode, parentVNode.scopeId, parentVNode.slotScopeIds, parentComponent.parent);
-				}
-			}
-		};
-		const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
-			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;
-			let { patchFlag, dynamicChildren, dirs } = n2;
-			patchFlag |= n1.patchFlag & 16;
-			const oldProps = n1.props || shared.EMPTY_OBJ;
-			const newProps = n2.props || shared.EMPTY_OBJ;
-			let vnodeHook;
-			parentComponent && toggleRecurse(parentComponent, false);
-			if (vnodeHook = newProps.onVnodeBeforeUpdate) invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
-			if (dirs) invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
-			parentComponent && toggleRecurse(parentComponent, true);
-			if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) hostSetElementText(el, "");
-			if (dynamicChildren) patchBlockChildren(n1.dynamicChildren, dynamicChildren, el, parentComponent, parentSuspense, resolveChildrenNamespace(n2, namespace), slotScopeIds);
-			else if (!optimized) patchChildren(n1, n2, el, null, parentComponent, parentSuspense, resolveChildrenNamespace(n2, namespace), slotScopeIds, false);
-			if (patchFlag > 0) {
-				if (patchFlag & 16) patchProps(el, oldProps, newProps, parentComponent, namespace);
-				else {
-					if (patchFlag & 2) {
-						if (oldProps.class !== newProps.class) hostPatchProp(el, "class", null, newProps.class, namespace);
-					}
-					if (patchFlag & 4) hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
-					if (patchFlag & 8) {
-						const propsToUpdate = n2.dynamicProps;
-						for (let i = 0; i < propsToUpdate.length; i++) {
-							const key = propsToUpdate[i];
-							const prev = oldProps[key];
-							const next = newProps[key];
-							if (next !== prev || key === "value") hostPatchProp(el, key, prev, next, namespace, parentComponent);
-						}
-					}
-				}
-				if (patchFlag & 1) {
-					if (n1.children !== n2.children) hostSetElementText(el, n2.children);
-				}
-			} else if (!optimized && dynamicChildren == null) patchProps(el, oldProps, newProps, parentComponent, namespace);
-			if ((vnodeHook = newProps.onVnodeUpdated) || dirs) queuePostRenderEffect(() => {
-				vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
-				dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
-			}, parentSuspense);
-		};
-		const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
-			for (let i = 0; i < newChildren.length; i++) {
-				const oldVNode = oldChildren[i];
-				const newVNode = newChildren[i];
-				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) => {
-			if (oldProps !== newProps) {
-				if (oldProps !== shared.EMPTY_OBJ) {
-					for (const key in oldProps) if (!shared.isReservedProp(key) && !(key in newProps)) hostPatchProp(el, key, oldProps[key], null, namespace, parentComponent);
-				}
-				for (const key in newProps) {
-					if (shared.isReservedProp(key)) continue;
-					const next = newProps[key];
-					const prev = oldProps[key];
-					if (next !== prev && key !== "value") hostPatchProp(el, key, prev, next, namespace, parentComponent);
-				}
-				if ("value" in newProps) hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
-			}
-		};
-		const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
-			const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
-			const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
-			let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
-			if (fragmentSlotScopeIds) slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
-			if (n1 == null) {
-				hostInsert(fragmentStartAnchor, container, anchor);
-				hostInsert(fragmentEndAnchor, container, anchor);
-				mountChildren(n2.children || [], container, fragmentEndAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-			} else if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && n1.dynamicChildren) {
-				patchBlockChildren(n1.dynamicChildren, dynamicChildren, container, parentComponent, parentSuspense, namespace, slotScopeIds);
-				if (n2.key != null || parentComponent && n2 === parentComponent.subTree) traverseStaticChildren(n1, n2, true);
-			} else patchChildren(n1, n2, container, fragmentEndAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-		};
-		const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
-			n2.slotScopeIds = slotScopeIds;
-			if (n1 == null) if (n2.shapeFlag & 512) parentComponent.ctx.activate(n2, container, anchor, namespace, optimized);
-			else mountComponent(n2, container, anchor, parentComponent, parentSuspense, namespace, optimized);
-			else updateComponent(n1, n2, optimized);
-		};
-		const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
-			const instance = initialVNode.component = createComponentInstance(initialVNode, parentComponent, parentSuspense);
-			if (isKeepAlive(initialVNode)) instance.ctx.renderer = internals;
-			setupComponent(instance, false, optimized);
-			if (instance.asyncDep) {
-				parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
-				if (!initialVNode.el) {
-					const placeholder = instance.subTree = createVNode(Comment);
-					processCommentNode(null, placeholder, container, anchor);
-					initialVNode.placeholder = placeholder.el;
-				}
-			} else setupRenderEffect(instance, initialVNode, container, anchor, parentSuspense, namespace, optimized);
-		};
-		const updateComponent = (n1, n2, optimized) => {
-			const instance = n2.component = n1.component;
-			if (shouldUpdateComponent(n1, n2, optimized)) if (instance.asyncDep && !instance.asyncResolved) {
-				updateComponentPreRender(instance, n2, optimized);
-				return;
-			} else {
-				instance.next = n2;
-				instance.update();
-			}
-			else {
-				n2.el = n1.el;
-				instance.vnode = n2;
-			}
-		};
-		const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
-			const componentUpdateFn = () => {
-				if (!instance.isMounted) {
-					let vnodeHook;
-					const { el, props } = initialVNode;
-					const { bm, m, parent, root, type } = instance;
-					const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
-					toggleRecurse(instance, false);
-					if (bm) shared.invokeArrayFns(bm);
-					if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) invokeVNodeHook(vnodeHook, parent, initialVNode);
-					toggleRecurse(instance, true);
-					if (el && hydrateNode) {
-						const hydrateSubTree = () => {
-							instance.subTree = renderComponentRoot(instance);
-							hydrateNode(el, instance.subTree, instance, parentSuspense, null);
-						};
-						if (isAsyncWrapperVNode && type.__asyncHydrate) type.__asyncHydrate(el, instance, hydrateSubTree);
-						else hydrateSubTree();
-					} else {
-						if (root.ce && root.ce._def.shadowRoot !== false) root.ce._injectChildStyle(type);
-						const subTree = instance.subTree = renderComponentRoot(instance);
-						patch(null, subTree, container, anchor, instance, parentSuspense, namespace);
-						initialVNode.el = subTree.el;
-					}
-					if (m) queuePostRenderEffect(m, parentSuspense);
-					if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
-						const scopedInitialVNode = initialVNode;
-						queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), parentSuspense);
-					}
-					if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) instance.a && queuePostRenderEffect(instance.a, parentSuspense);
-					instance.isMounted = true;
-					initialVNode = container = anchor = null;
-				} else {
-					let { next, bu, u, parent, vnode } = instance;
-					{
-						const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
-						if (nonHydratedAsyncRoot) {
-							if (next) {
-								next.el = vnode.el;
-								updateComponentPreRender(instance, next, optimized);
-							}
-							nonHydratedAsyncRoot.asyncDep.then(() => {
-								if (!instance.isUnmounted) componentUpdateFn();
-							});
-							return;
-						}
-					}
-					let originNext = next;
-					let vnodeHook;
-					toggleRecurse(instance, false);
-					if (next) {
-						next.el = vnode.el;
-						updateComponentPreRender(instance, next, optimized);
-					} else next = vnode;
-					if (bu) shared.invokeArrayFns(bu);
-					if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) invokeVNodeHook(vnodeHook, parent, next, vnode);
-					toggleRecurse(instance, true);
-					const nextTree = renderComponentRoot(instance);
-					const prevTree = instance.subTree;
-					instance.subTree = nextTree;
-					patch(prevTree, nextTree, hostParentNode(prevTree.el), getNextHostNode(prevTree), instance, parentSuspense, namespace);
-					next.el = nextTree.el;
-					if (originNext === null) updateHOCHostEl(instance, nextTree.el);
-					if (u) queuePostRenderEffect(u, parentSuspense);
-					if (vnodeHook = next.props && next.props.onVnodeUpdated) queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, next, vnode), parentSuspense);
-				}
-			};
-			instance.scope.on();
-			const effect = instance.effect = new reactivity.ReactiveEffect(componentUpdateFn);
-			instance.scope.off();
-			const update = instance.update = effect.run.bind(effect);
-			const job = instance.job = effect.runIfDirty.bind(effect);
-			job.i = instance;
-			job.id = instance.uid;
-			effect.scheduler = () => queueJob(job);
-			toggleRecurse(instance, true);
-			update();
-		};
-		const updateComponentPreRender = (instance, nextVNode, optimized) => {
-			nextVNode.component = instance;
-			const prevProps = instance.vnode.props;
-			instance.vnode = nextVNode;
-			instance.next = null;
-			updateProps(instance, nextVNode.props, prevProps, optimized);
-			updateSlots(instance, nextVNode.children, optimized);
-			reactivity.pauseTracking();
-			flushPreFlushCbs(instance);
-			reactivity.resetTracking();
-		};
-		const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
-			const c1 = n1 && n1.children;
-			const prevShapeFlag = n1 ? n1.shapeFlag : 0;
-			const c2 = n2.children;
-			const { patchFlag, shapeFlag } = n2;
-			if (patchFlag > 0) {
-				if (patchFlag & 128) {
-					patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-					return;
-				} else if (patchFlag & 256) {
-					patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-					return;
-				}
-			}
-			if (shapeFlag & 8) {
-				if (prevShapeFlag & 16) unmountChildren(c1, parentComponent, parentSuspense);
-				if (c2 !== c1) hostSetElementText(container, c2);
-			} else if (prevShapeFlag & 16) if (shapeFlag & 16) patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-			else unmountChildren(c1, parentComponent, parentSuspense, true);
-			else {
-				if (prevShapeFlag & 8) hostSetElementText(container, "");
-				if (shapeFlag & 16) mountChildren(c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-			}
-		};
-		const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
-			c1 = c1 || shared.EMPTY_ARR;
-			c2 = c2 || shared.EMPTY_ARR;
-			const oldLength = c1.length;
-			const newLength = c2.length;
-			const commonLength = Math.min(oldLength, newLength);
-			let i;
-			for (i = 0; i < commonLength; i++) {
-				const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
-				patch(c1[i], nextChild, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-			}
-			if (oldLength > newLength) unmountChildren(c1, parentComponent, parentSuspense, true, false, commonLength);
-			else mountChildren(c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, commonLength);
-		};
-		const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
-			let i = 0;
-			const l2 = c2.length;
-			let e1 = c1.length - 1;
-			let e2 = l2 - 1;
-			while (i <= e1 && i <= e2) {
-				const n1 = c1[i];
-				const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
-				if (isSameVNodeType(n1, n2)) patch(n1, n2, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-				else break;
-				i++;
-			}
-			while (i <= e1 && i <= e2) {
-				const n1 = c1[e1];
-				const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
-				if (isSameVNodeType(n1, n2)) patch(n1, n2, container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-				else break;
-				e1--;
-				e2--;
-			}
-			if (i > e1) {
-				if (i <= e2) {
-					const nextPos = e2 + 1;
-					const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
-					while (i <= e2) {
-						patch(null, c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]), container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-						i++;
-					}
-				}
-			} else if (i > e2) while (i <= e1) {
-				unmount(c1[i], parentComponent, parentSuspense, true);
-				i++;
-			}
-			else {
-				const s1 = i;
-				const s2 = i;
-				const keyToNewIndexMap = /* @__PURE__ */ new Map();
-				for (i = s2; i <= e2; i++) {
-					const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
-					if (nextChild.key != null) keyToNewIndexMap.set(nextChild.key, i);
-				}
-				let j;
-				let patched = 0;
-				const toBePatched = e2 - s2 + 1;
-				let moved = false;
-				let maxNewIndexSoFar = 0;
-				const newIndexToOldIndexMap = new Array(toBePatched);
-				for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
-				for (i = s1; i <= e1; i++) {
-					const prevChild = c1[i];
-					if (patched >= toBePatched) {
-						unmount(prevChild, parentComponent, parentSuspense, true);
-						continue;
-					}
-					let newIndex;
-					if (prevChild.key != null) newIndex = keyToNewIndexMap.get(prevChild.key);
-					else for (j = s2; j <= e2; j++) if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
-						newIndex = j;
-						break;
-					}
-					if (newIndex === void 0) unmount(prevChild, parentComponent, parentSuspense, true);
-					else {
-						newIndexToOldIndexMap[newIndex - s2] = i + 1;
-						if (newIndex >= maxNewIndexSoFar) maxNewIndexSoFar = newIndex;
-						else moved = true;
-						patch(prevChild, c2[newIndex], container, null, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-						patched++;
-					}
-				}
-				const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : shared.EMPTY_ARR;
-				j = increasingNewIndexSequence.length - 1;
-				for (i = toBePatched - 1; i >= 0; i--) {
-					const nextIndex = s2 + i;
-					const nextChild = c2[nextIndex];
-					const anchorVNode = c2[nextIndex + 1];
-					const anchor = nextIndex + 1 < l2 ? anchorVNode.el || anchorVNode.placeholder : parentAnchor;
-					if (newIndexToOldIndexMap[i] === 0) patch(null, nextChild, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized);
-					else if (moved) if (j < 0 || i !== increasingNewIndexSequence[j]) move(nextChild, container, anchor, 2);
-					else j--;
-				}
-			}
-		};
-		const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
-			const { el, type, transition, children, shapeFlag } = vnode;
-			if (shapeFlag & 6) {
-				move(vnode.component.subTree, container, anchor, moveType);
-				return;
-			}
-			if (shapeFlag & 128) {
-				vnode.suspense.move(container, anchor, moveType);
-				return;
-			}
-			if (shapeFlag & 64) {
-				type.move(vnode, container, anchor, internals);
-				return;
-			}
-			if (type === Fragment) {
-				hostInsert(el, container, anchor);
-				for (let i = 0; i < children.length; i++) move(children[i], container, anchor, moveType);
-				hostInsert(vnode.anchor, container, anchor);
-				return;
-			}
-			if (type === Static) {
-				moveStaticNode(vnode, container, anchor);
-				return;
-			}
-			if (moveType !== 2 && shapeFlag & 1 && transition) if (moveType === 0) {
-				transition.beforeEnter(el);
-				hostInsert(el, container, anchor);
-				queuePostRenderEffect(() => transition.enter(el), parentSuspense);
-			} else {
-				const { leave, delayLeave, afterLeave } = transition;
-				const remove2 = () => {
-					if (vnode.ctx.isUnmounted) hostRemove(el);
-					else hostInsert(el, container, anchor);
-				};
-				const performLeave = () => {
-					if (el._isLeaving) el[leaveCbKey](true);
-					leave(el, () => {
-						remove2();
-						afterLeave && afterLeave();
-					});
-				};
-				if (delayLeave) delayLeave(el, remove2, performLeave);
-				else performLeave();
-			}
-			else hostInsert(el, container, anchor);
-		};
-		const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
-			const { type, props, ref, children, dynamicChildren, shapeFlag, patchFlag, dirs, cacheIndex } = vnode;
-			if (patchFlag === -2) optimized = false;
-			if (ref != null) {
-				reactivity.pauseTracking();
-				setRef(ref, null, parentSuspense, vnode, true);
-				reactivity.resetTracking();
-			}
-			if (cacheIndex != null) parentComponent.renderCache[cacheIndex] = void 0;
-			if (shapeFlag & 256) {
-				parentComponent.ctx.deactivate(vnode);
-				return;
-			}
-			const shouldInvokeDirs = shapeFlag & 1 && dirs;
-			const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
-			let vnodeHook;
-			if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) invokeVNodeHook(vnodeHook, parentComponent, vnode);
-			if (shapeFlag & 6) unmountComponent(vnode.component, parentSuspense, doRemove);
-			else {
-				if (shapeFlag & 128) {
-					vnode.suspense.unmount(parentSuspense, doRemove);
-					return;
-				}
-				if (shouldInvokeDirs) invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
-				if (shapeFlag & 64) vnode.type.remove(vnode, parentComponent, parentSuspense, internals, doRemove);
-				else if (dynamicChildren && !dynamicChildren.hasOnce && (type !== Fragment || patchFlag > 0 && patchFlag & 64)) unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true);
-				else if (type === Fragment && patchFlag & 384 || !optimized && shapeFlag & 16) unmountChildren(children, parentComponent, parentSuspense);
-				if (doRemove) remove(vnode);
-			}
-			if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) queuePostRenderEffect(() => {
-				vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
-				shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
-			}, parentSuspense);
-		};
-		const remove = (vnode) => {
-			const { type, el, anchor, transition } = vnode;
-			if (type === Fragment) {
-				removeFragment(el, anchor);
-				return;
-			}
-			if (type === Static) {
-				removeStaticNode(vnode);
-				return;
-			}
-			const performRemove = () => {
-				hostRemove(el);
-				if (transition && !transition.persisted && transition.afterLeave) transition.afterLeave();
-			};
-			if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
-				const { leave, delayLeave } = transition;
-				const performLeave = () => leave(el, performRemove);
-				if (delayLeave) delayLeave(vnode.el, performRemove, performLeave);
-				else performLeave();
-			} else performRemove();
-		};
-		const removeFragment = (cur, end) => {
-			let next;
-			while (cur !== end) {
-				next = hostNextSibling(cur);
-				hostRemove(cur);
-				cur = next;
-			}
-			hostRemove(end);
-		};
-		const unmountComponent = (instance, parentSuspense, doRemove) => {
-			const { bum, scope, job, subTree, um, m, a } = instance;
-			invalidateMount(m);
-			invalidateMount(a);
-			if (bum) shared.invokeArrayFns(bum);
-			scope.stop();
-			if (job) {
-				job.flags |= 8;
-				unmount(subTree, instance, parentSuspense, doRemove);
-			}
-			if (um) queuePostRenderEffect(um, parentSuspense);
-			queuePostRenderEffect(() => {
-				instance.isUnmounted = true;
-			}, parentSuspense);
-		};
-		const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
-			for (let i = start; i < children.length; i++) unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
-		};
-		const getNextHostNode = (vnode) => {
-			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 = (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,
-			mt: mountComponent,
-			mc: mountChildren,
-			pc: patchChildren,
-			pbc: patchBlockChildren,
-			n: getNextHostNode,
-			o: options
-		};
-		let hydrate;
-		let hydrateNode;
-		if (createHydrationFns) [hydrate, hydrateNode] = createHydrationFns(internals);
-		return {
-			render,
-			hydrate,
-			createApp: createAppAPI(render, hydrate)
-		};
-	}
-	function resolveChildrenNamespace({ type, props }, currentNamespace) {
-		return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
-	}
-	function toggleRecurse({ effect, job }, allowed) {
-		if (allowed) {
-			effect.flags |= 32;
-			job.flags |= 4;
-		} else {
-			effect.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 (shared.isArray(ch1) && shared.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;
-		}
-	}
-	function getSequence(arr) {
-		const p = 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[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[i] = result[u - 1];
-					result[u] = i;
-				}
-			}
-		}
-		u = result.length;
-		v = result[u - 1];
-		while (u-- > 0) {
-			result[u] = v;
-			v = p[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 = () => {
-		return inject(ssrContextKey);
-	};
-	function watchEffect(effect, options) {
-		return doWatch(effect, null, options);
-	}
-	function watchPostEffect(effect, options) {
-		return doWatch(effect, null, { flush: "post" });
-	}
-	function watchSyncEffect(effect, options) {
-		return doWatch(effect, null, { flush: "sync" });
-	}
-	function watch(source, cb, options) {
-		return doWatch(source, cb, options);
-	}
-	function doWatch(source, cb, options = shared.EMPTY_OBJ) {
-		const { immediate, deep, flush, once } = options;
-		const baseWatchOptions = shared.extend({}, options);
-		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 = shared.NOOP;
-				watchStopHandle.resume = shared.NOOP;
-				watchStopHandle.pause = shared.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 = reactivity.watch(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 = shared.isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
-		let cb;
-		if (shared.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 = shared.EMPTY_OBJ) {
-		const i = getCurrentInstance();
-		const camelizedName = shared.camelize(name);
-		const hyphenatedName = shared.hyphenate(name);
-		const modifiers = getModelModifiers(props, camelizedName);
-		const res = reactivity.customRef((track, trigger) => {
-			let localValue;
-			let prevSetValue = shared.EMPTY_OBJ;
-			let prevEmittedValue;
-			watchSyncEffect(() => {
-				const propValue = props[camelizedName];
-				if (shared.hasChanged(localValue, propValue)) {
-					localValue = propValue;
-					trigger();
-				}
-			});
-			return {
-				get() {
-					track();
-					return options.get ? options.get(localValue) : localValue;
-				},
-				set(value) {
-					const emittedValue = options.set ? options.set(value) : value;
-					if (!shared.hasChanged(emittedValue, localValue) && !(prevSetValue !== shared.EMPTY_OBJ && shared.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();
-					}
-					i.emit(`update:${name}`, emittedValue);
-					if (shared.hasChanged(value, emittedValue) && shared.hasChanged(value, prevSetValue) && !shared.hasChanged(emittedValue, prevEmittedValue)) trigger();
-					prevSetValue = value;
-					prevEmittedValue = emittedValue;
-				}
-			};
-		});
-		res[Symbol.iterator] = () => {
-			let i2 = 0;
-			return { next() {
-				if (i2 < 2) return {
-					value: i2++ ? modifiers || shared.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[`${shared.camelize(modelName)}Modifiers`] || props[`${shared.hyphenate(modelName)}Modifiers`];
-	};
-	function emit(instance, event, ...rawArgs) {
-		if (instance.isUnmounted) return;
-		const props = instance.vnode.props || shared.EMPTY_OBJ;
-		let args = rawArgs;
-		const isModelListener = event.startsWith("update:");
-		const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
-		if (modifiers) {
-			if (modifiers.trim) args = rawArgs.map((a) => shared.isString(a) ? a.trim() : a);
-			if (modifiers.number) args = rawArgs.map(shared.looseToNumber);
-		}
-		let handlerName;
-		let handler = props[handlerName = shared.toHandlerKey(event)] || props[handlerName = shared.toHandlerKey(shared.camelize(event))];
-		if (!handler && isModelListener) handler = props[handlerName = shared.toHandlerKey(shared.hyphenate(event))];
-		if (handler) callWithAsyncErrorHandling(handler, instance, 6, args);
-		const onceHandler = props[handlerName + `Once`];
-		if (onceHandler) {
-			if (!instance.emitted) instance.emitted = {};
-			else if (instance.emitted[handlerName]) return;
-			instance.emitted[handlerName] = true;
-			callWithAsyncErrorHandling(onceHandler, instance, 6, args);
-		}
-	}
-	const mixinEmitsCache = /* @__PURE__ */ new WeakMap();
-	function normalizeEmitsOptions(comp, appContext, asMixin = false) {
-		const cache = 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 (!shared.isFunction(comp)) {
-			const extendEmits = (raw2) => {
-				const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
-				if (normalizedFromExtend) {
-					hasExtends = true;
-					shared.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 (shared.isObject(comp)) cache.set(comp, null);
-			return null;
-		}
-		if (shared.isArray(raw)) raw.forEach((key) => normalized[key] = null);
-		else shared.extend(normalized, raw);
-		if (shared.isObject(comp)) cache.set(comp, normalized);
-		return normalized;
-	}
-	function isEmitListener(options, key) {
-		if (!options || !shared.isOn(key)) return false;
-		key = key.slice(2).replace(/Once$/, "");
-		return shared.hasOwn(options, key[0].toLowerCase() + key.slice(1)) || shared.hasOwn(options, shared.hyphenate(key)) || shared.hasOwn(options, key);
-	}
-	function renderComponentRoot(instance) {
-		const { type: Component, vnode, proxy, withProxy, propsOptions: [propsOptions], slots, attrs, emit: emit$1, render, renderCache, props, data, setupState, ctx, inheritAttrs } = instance;
-		const prev = setCurrentRenderingInstance(instance);
-		let result;
-		let fallthroughAttrs;
-		try {
-			if (vnode.shapeFlag & 4) {
-				const proxyToUse = withProxy || proxy;
-				const thisProxy = proxyToUse;
-				result = normalizeVNode(render.call(thisProxy, proxyToUse, renderCache, props, setupState, data, ctx));
-				fallthroughAttrs = attrs;
-			} else {
-				const render2 = Component;
-				result = normalizeVNode(render2.length > 1 ? render2(props, {
-					attrs,
-					slots,
-					emit: emit$1
-				}) : render2(props, null));
-				fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
-			}
-		} catch (err) {
-			blockStack.length = 0;
-			handleError(err, instance, 1);
-			result = createVNode(Comment);
-		}
-		let root = result;
-		if (fallthroughAttrs && inheritAttrs !== false) {
-			const keys = Object.keys(fallthroughAttrs);
-			const { shapeFlag } = root;
-			if (keys.length) {
-				if (shapeFlag & 7) {
-					if (propsOptions && keys.some(shared.isModelListener)) fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
-					root = cloneVNode(root, fallthroughAttrs, false, true);
-				}
-			}
-		}
-		if (vnode.dirs) {
-			root = cloneVNode(root, null, false, true);
-			root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
-		}
-		if (vnode.transition) setTransitionHooks(root, vnode.transition);
-		result = root;
-		setCurrentRenderingInstance(prev);
-		return result;
-	}
-	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;
-			} else return;
-		}
-		return singleRoot;
-	}
-	const getFunctionalFallthrough = (attrs) => {
-		let res;
-		for (const key in attrs) if (key === "class" || key === "style" || shared.isOn(key)) (res || (res = {}))[key] = attrs[key];
-		return res;
-	};
-	const filterModelListeners = (attrs, props) => {
-		const res = {};
-		for (const key in attrs) if (!shared.isModelListener(key) || !(key.slice(9) in props)) res[key] = attrs[key];
-		return res;
-	};
-	function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
-		const { props: prevProps, children: prevChildren, component } = prevVNode;
-		const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
-		const emits = component.emitsOptions;
-		if (nextVNode.dirs || nextVNode.transition) return true;
-		if (optimized && patchFlag >= 0) {
-			if (patchFlag & 1024) return true;
-			if (patchFlag & 16) {
-				if (!prevProps) return !!nextProps;
-				return hasPropsChanged(prevProps, nextProps, emits);
-			} else if (patchFlag & 8) {
-				const dynamicProps = nextVNode.dynamicProps;
-				for (let i = 0; i < dynamicProps.length; i++) {
-					const key = dynamicProps[i];
-					if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) return true;
-				}
-			}
-		} else {
-			if (prevChildren || nextChildren) {
-				if (!nextChildren || !nextChildren.$stable) return true;
-			}
-			if (prevProps === nextProps) return false;
-			if (!prevProps) return !!nextProps;
-			if (!nextProps) return true;
-			return hasPropsChanged(prevProps, nextProps, emits);
-		}
-		return false;
-	}
-	function hasPropsChanged(prevProps, nextProps, emitsOptions) {
-		const nextKeys = Object.keys(nextProps);
-		if (nextKeys.length !== Object.keys(prevProps).length) return true;
-		for (let i = 0; i < nextKeys.length; i++) {
-			const key = nextKeys[i];
-			if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) return true;
-		}
-		return false;
-	}
-	function updateHOCHostEl({ vnode, parent }, el) {
-		while (parent) {
-			const root = parent.subTree;
-			if (root.suspense && root.suspense.activeBranch === vnode) root.el = vnode.el;
-			if (root === vnode) {
-				(vnode = parent.vnode).el = el;
-				parent = parent.parent;
-			} else break;
-		}
-	}
-	const isSuspense = (type) => type.__isSuspense;
-	let suspenseId = 0;
-	const Suspense = {
-		name: "Suspense",
-		__isSuspense: true,
-		process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
-			if (n1 == null) mountSuspense(n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals);
-			else {
-				if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
-					n2.suspense = n1.suspense;
-					n2.suspense.vnode = n2;
-					n2.el = n1.el;
-					return;
-				}
-				patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, rendererInternals);
-			}
-		},
-		hydrate: hydrateSuspense,
-		normalize: normalizeSuspenseChildren
-	};
-	function triggerEvent(vnode, name) {
-		const eventListener = vnode.props && vnode.props[name];
-		if (shared.isFunction(eventListener)) eventListener();
-	}
-	function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
-		const { p: patch, o: { createElement } } = rendererInternals;
-		const hiddenContainer = createElement("div");
-		const suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals);
-		patch(null, suspense.pendingBranch = vnode.ssContent, hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds);
-		if (suspense.deps > 0) {
-			triggerEvent(vnode, "onPending");
-			triggerEvent(vnode, "onFallback");
-			patch(null, vnode.ssFallback, container, anchor, parentComponent, null, namespace, slotScopeIds);
-			setActiveBranch(suspense, vnode.ssFallback);
-		} else suspense.resolve(false, true);
-	}
-	function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
-		const suspense = n2.suspense = n1.suspense;
-		suspense.vnode = n2;
-		n2.el = n1.el;
-		const newBranch = n2.ssContent;
-		const newFallback = n2.ssFallback;
-		const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
-		if (pendingBranch) {
-			suspense.pendingBranch = newBranch;
-			if (isSameVNodeType(pendingBranch, newBranch)) {
-				patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
-				if (suspense.deps <= 0) suspense.resolve();
-				else if (isInFallback) {
-					if (!isHydrating) {
-						patch(activeBranch, newFallback, container, anchor, parentComponent, null, namespace, slotScopeIds, optimized);
-						setActiveBranch(suspense, newFallback);
-					}
-				}
-			} else {
-				suspense.pendingId = suspenseId++;
-				if (isHydrating) {
-					suspense.isHydrating = false;
-					suspense.activeBranch = pendingBranch;
-				} else unmount(pendingBranch, parentComponent, suspense);
-				suspense.deps = 0;
-				suspense.effects.length = 0;
-				suspense.hiddenContainer = createElement("div");
-				if (isInFallback) {
-					patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
-					if (suspense.deps <= 0) suspense.resolve();
-					else {
-						patch(activeBranch, newFallback, container, anchor, parentComponent, null, namespace, slotScopeIds, optimized);
-						setActiveBranch(suspense, newFallback);
-					}
-				} else if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
-					patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, namespace, slotScopeIds, optimized);
-					suspense.resolve(true);
-				} else {
-					patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
-					if (suspense.deps <= 0) suspense.resolve();
-				}
-			}
-		} else if (activeBranch && isSameVNodeType(activeBranch, newBranch)) {
-			patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, namespace, slotScopeIds, optimized);
-			setActiveBranch(suspense, newBranch);
-		} else {
-			triggerEvent(n2, "onPending");
-			suspense.pendingBranch = newBranch;
-			if (newBranch.shapeFlag & 512) suspense.pendingId = newBranch.component.suspenseId;
-			else suspense.pendingId = suspenseId++;
-			patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, namespace, slotScopeIds, optimized);
-			if (suspense.deps <= 0) suspense.resolve();
-			else {
-				const { timeout, pendingId } = suspense;
-				if (timeout > 0) setTimeout(() => {
-					if (suspense.pendingId === pendingId) suspense.fallback(newFallback);
-				}, timeout);
-				else if (timeout === 0) suspense.fallback(newFallback);
-			}
-		}
-	}
-	function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
-		const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove } } = rendererInternals;
-		let parentSuspenseId;
-		const isSuspensible = isVNodeSuspensible(vnode);
-		if (isSuspensible) {
-			if (parentSuspense && parentSuspense.pendingBranch) {
-				parentSuspenseId = parentSuspense.pendingId;
-				parentSuspense.deps++;
-			}
-		}
-		const timeout = vnode.props ? shared.toNumber(vnode.props.timeout) : void 0;
-		const initialAnchor = anchor;
-		const suspense = {
-			vnode,
-			parent: parentSuspense,
-			parentComponent,
-			namespace,
-			container,
-			hiddenContainer,
-			deps: 0,
-			pendingId: suspenseId++,
-			timeout: typeof timeout === "number" ? timeout : -1,
-			activeBranch: null,
-			pendingBranch: null,
-			isInFallback: !isHydrating,
-			isHydrating,
-			isUnmounted: false,
-			effects: [],
-			resolve(resume = false, sync = false) {
-				const { vnode: vnode2, activeBranch, pendingBranch, pendingId, effects, parentComponent: parentComponent2, container: container2 } = suspense;
-				let delayEnter = false;
-				if (suspense.isHydrating) suspense.isHydrating = false;
-				else if (!resume) {
-					delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
-					if (delayEnter) activeBranch.transition.afterLeave = () => {
-						if (pendingId === suspense.pendingId) {
-							move(pendingBranch, container2, anchor === initialAnchor ? next(activeBranch) : anchor, 0);
-							queuePostFlushCb(effects);
-						}
-					};
-					if (activeBranch) {
-						if (parentNode(activeBranch.el) === container2) anchor = next(activeBranch);
-						unmount(activeBranch, parentComponent2, suspense, true);
-					}
-					if (!delayEnter) move(pendingBranch, container2, anchor, 0);
-				}
-				setActiveBranch(suspense, pendingBranch);
-				suspense.pendingBranch = null;
-				suspense.isInFallback = false;
-				let parent = suspense.parent;
-				let hasUnresolvedAncestor = false;
-				while (parent) {
-					if (parent.pendingBranch) {
-						parent.effects.push(...effects);
-						hasUnresolvedAncestor = true;
-						break;
-					}
-					parent = parent.parent;
-				}
-				if (!hasUnresolvedAncestor && !delayEnter) queuePostFlushCb(effects);
-				suspense.effects = [];
-				if (isSuspensible) {
-					if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
-						parentSuspense.deps--;
-						if (parentSuspense.deps === 0 && !sync) parentSuspense.resolve();
-					}
-				}
-				triggerEvent(vnode2, "onResolve");
-			},
-			fallback(fallbackVNode) {
-				if (!suspense.pendingBranch) return;
-				const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
-				triggerEvent(vnode2, "onFallback");
-				const anchor2 = next(activeBranch);
-				const mountFallback = () => {
-					if (!suspense.isInFallback) return;
-					patch(null, fallbackVNode, container2, anchor2, parentComponent2, null, namespace2, slotScopeIds, optimized);
-					setActiveBranch(suspense, fallbackVNode);
-				};
-				const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
-				if (delayEnter) activeBranch.transition.afterLeave = mountFallback;
-				suspense.isInFallback = true;
-				unmount(activeBranch, parentComponent2, null, true);
-				if (!delayEnter) mountFallback();
-			},
-			move(container2, anchor2, type) {
-				suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
-				suspense.container = container2;
-			},
-			next() {
-				return suspense.activeBranch && next(suspense.activeBranch);
-			},
-			registerDep(instance, setupRenderEffect, optimized2) {
-				const isInPendingSuspense = !!suspense.pendingBranch;
-				if (isInPendingSuspense) suspense.deps++;
-				const hydratedEl = instance.vnode.el;
-				instance.asyncDep.catch((err) => {
-					handleError(err, instance, 0);
-				}).then((asyncSetupResult) => {
-					if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) return;
-					instance.asyncResolved = true;
-					const { vnode: vnode2 } = instance;
-					handleSetupResult(instance, asyncSetupResult, false);
-					if (hydratedEl) vnode2.el = hydratedEl;
-					const placeholder = !hydratedEl && instance.subTree.el;
-					setupRenderEffect(instance, vnode2, parentNode(hydratedEl || instance.subTree.el), hydratedEl ? null : next(instance.subTree), suspense, namespace, optimized2);
-					if (placeholder) remove(placeholder);
-					updateHOCHostEl(instance, vnode2.el);
-					if (isInPendingSuspense && --suspense.deps === 0) suspense.resolve();
-				});
-			},
-			unmount(parentSuspense2, doRemove) {
-				suspense.isUnmounted = true;
-				if (suspense.activeBranch) unmount(suspense.activeBranch, parentComponent, parentSuspense2, doRemove);
-				if (suspense.pendingBranch) unmount(suspense.pendingBranch, parentComponent, parentSuspense2, doRemove);
-			}
-		};
-		return suspense;
-	}
-	function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) {
-		const suspense = vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement("div"), null, namespace, slotScopeIds, optimized, rendererInternals, true);
-		const result = hydrateNode(node, suspense.pendingBranch = vnode.ssContent, parentComponent, suspense, slotScopeIds, optimized);
-		if (suspense.deps === 0) suspense.resolve(false, true);
-		return result;
-	}
-	function normalizeSuspenseChildren(vnode) {
-		const { shapeFlag, children } = vnode;
-		const isSlotChildren = shapeFlag & 32;
-		vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children);
-		vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
-	}
-	function normalizeSuspenseSlot(s) {
-		let block;
-		if (shared.isFunction(s)) {
-			const trackBlock = isBlockTreeEnabled && s._c;
-			if (trackBlock) {
-				s._d = false;
-				openBlock();
-			}
-			s = s();
-			if (trackBlock) {
-				s._d = true;
-				block = currentBlock;
-				closeBlock();
-			}
-		}
-		if (shared.isArray(s)) s = filterSingleRoot(s);
-		s = normalizeVNode(s);
-		if (block && !s.dynamicChildren) s.dynamicChildren = block.filter((c) => c !== s);
-		return s;
-	}
-	function queueEffectWithSuspense(fn, suspense) {
-		if (suspense && suspense.pendingBranch) if (shared.isArray(fn)) suspense.effects.push(...fn);
-		else suspense.effects.push(fn);
-		else queuePostFlushCb(fn);
-	}
-	function setActiveBranch(suspense, branch) {
-		suspense.activeBranch = branch;
-		const { vnode, parentComponent } = suspense;
-		let el = branch.el;
-		while (!el && branch.component) {
-			branch = branch.component.subTree;
-			el = branch.el;
-		}
-		vnode.el = el;
-		if (parentComponent && parentComponent.subTree === vnode) {
-			parentComponent.vnode.el = el;
-			updateHOCHostEl(parentComponent, el);
-		}
-	}
-	function isVNodeSuspensible(vnode) {
-		const suspensible = vnode.props && vnode.props.suspensible;
-		return suspensible != null && suspensible !== false;
-	}
-	const Fragment = Symbol.for("v-fgt");
-	const Text = Symbol.for("v-txt");
-	const Comment = Symbol.for("v-cmt");
-	const Static = Symbol.for("v-stc");
-	const blockStack = [];
-	let currentBlock = null;
-	function openBlock(disableTracking = false) {
-		blockStack.push(currentBlock = disableTracking ? null : []);
-	}
-	function closeBlock() {
-		blockStack.pop();
-		currentBlock = blockStack[blockStack.length - 1] || null;
-	}
-	let isBlockTreeEnabled = 1;
-	function setBlockTracking(value, inVOnce = false) {
-		isBlockTreeEnabled += value;
-		if (value < 0 && currentBlock && inVOnce) currentBlock.hasOnce = true;
-	}
-	function setupBlock(vnode) {
-		vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || shared.EMPTY_ARR : null;
-		closeBlock();
-		if (isBlockTreeEnabled > 0 && currentBlock) currentBlock.push(vnode);
-		return vnode;
-	}
-	function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
-		return setupBlock(createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, true));
-	}
-	function createBlock(type, props, children, patchFlag, dynamicProps) {
-		return setupBlock(createVNode(type, props, children, patchFlag, dynamicProps, true));
-	}
-	function isVNode(value) {
-		return value ? value.__v_isVNode === true : false;
-	}
-	function isSameVNodeType(n1, n2) {
-		return n1.type === n2.type && n1.key === n2.key;
-	}
-	function transformVNodeArgs(transformer) {}
-	const normalizeKey = ({ key }) => key != null ? key : null;
-	const normalizeRef = ({ ref, ref_key, ref_for }) => {
-		if (typeof ref === "number") ref = "" + ref;
-		return ref != null ? shared.isString(ref) || reactivity.isRef(ref) || shared.isFunction(ref) ? {
-			i: currentRenderingInstance,
-			r: ref,
-			k: ref_key,
-			f: !!ref_for
-		} : ref : null;
-	};
-	function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
-		const vnode = {
-			__v_isVNode: true,
-			__v_skip: true,
-			type,
-			props,
-			key: props && normalizeKey(props),
-			ref: props && normalizeRef(props),
-			scopeId: currentScopeId,
-			slotScopeIds: null,
-			children,
-			component: null,
-			suspense: null,
-			ssContent: null,
-			ssFallback: null,
-			dirs: null,
-			transition: null,
-			el: null,
-			anchor: null,
-			target: null,
-			targetStart: null,
-			targetAnchor: null,
-			staticCount: 0,
-			shapeFlag,
-			patchFlag,
-			dynamicProps,
-			dynamicChildren: null,
-			appContext: null,
-			ctx: currentRenderingInstance
-		};
-		if (needFullChildrenNormalization) {
-			normalizeChildren(vnode, children);
-			if (shapeFlag & 128) type.normalize(vnode);
-		} else if (children) vnode.shapeFlag |= shared.isString(children) ? 8 : 16;
-		if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (vnode.patchFlag > 0 || shapeFlag & 6) && vnode.patchFlag !== 32) currentBlock.push(vnode);
-		return vnode;
-	}
-	const createVNode = _createVNode;
-	function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
-		if (!type || type === NULL_DYNAMIC_COMPONENT) type = Comment;
-		if (isVNode(type)) {
-			const cloned = cloneVNode(type, props, true);
-			if (children) normalizeChildren(cloned, children);
-			if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) if (cloned.shapeFlag & 6) currentBlock[currentBlock.indexOf(type)] = cloned;
-			else currentBlock.push(cloned);
-			cloned.patchFlag = -2;
-			return cloned;
-		}
-		if (isClassComponent(type)) type = type.__vccOpts;
-		if (props) {
-			props = guardReactiveProps(props);
-			let { class: klass, style } = props;
-			if (klass && !shared.isString(klass)) props.class = shared.normalizeClass(klass);
-			if (shared.isObject(style)) {
-				if (reactivity.isProxy(style) && !shared.isArray(style)) style = shared.extend({}, style);
-				props.style = shared.normalizeStyle(style);
-			}
-		}
-		const shapeFlag = shared.isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : shared.isObject(type) ? 4 : shared.isFunction(type) ? 2 : 0;
-		return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true);
-	}
-	function guardReactiveProps(props) {
-		if (!props) return null;
-		return reactivity.isProxy(props) || isInternalObject(props) ? shared.extend({}, props) : props;
-	}
-	function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
-		const { props, ref, patchFlag, children, transition } = vnode;
-		const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
-		const cloned = {
-			__v_isVNode: true,
-			__v_skip: true,
-			type: vnode.type,
-			props: mergedProps,
-			key: mergedProps && normalizeKey(mergedProps),
-			ref: extraProps && extraProps.ref ? mergeRef && ref ? shared.isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
-			scopeId: vnode.scopeId,
-			slotScopeIds: vnode.slotScopeIds,
-			children,
-			target: vnode.target,
-			targetStart: vnode.targetStart,
-			targetAnchor: vnode.targetAnchor,
-			staticCount: vnode.staticCount,
-			shapeFlag: vnode.shapeFlag,
-			patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
-			dynamicProps: vnode.dynamicProps,
-			dynamicChildren: vnode.dynamicChildren,
-			appContext: vnode.appContext,
-			dirs: vnode.dirs,
-			transition,
-			component: vnode.component,
-			suspense: vnode.suspense,
-			ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
-			ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
-			placeholder: vnode.placeholder,
-			el: vnode.el,
-			anchor: vnode.anchor,
-			ctx: vnode.ctx,
-			ce: vnode.ce
-		};
-		if (transition && cloneTransition) setTransitionHooks(cloned, transition.clone(cloned));
-		return cloned;
-	}
-	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);
-	}
-	function normalizeVNode(child) {
-		if (child == null || typeof child === "boolean") return createVNode(Comment);
-		else if (shared.isArray(child)) return createVNode(Fragment, null, child.slice());
-		else if (isVNode(child)) return cloneIfMounted(child);
-		else return createVNode(Text, null, String(child));
-	}
-	function cloneIfMounted(child) {
-		return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
-	}
-	function normalizeChildren(vnode, children) {
-		let type = 0;
-		const { shapeFlag } = vnode;
-		if (children == null) children = null;
-		else if (shared.isArray(children)) type = 16;
-		else if (typeof children === "object") if (shapeFlag & 65) {
-			const slot = children.default;
-			if (slot) {
-				slot._c && (slot._d = false);
-				normalizeChildren(vnode, slot());
-				slot._c && (slot._d = true);
-			}
-			return;
-		} else {
-			type = 32;
-			const slotFlag = children._;
-			if (!slotFlag && !isInternalObject(children)) children._ctx = currentRenderingInstance;
-			else if (slotFlag === 3 && currentRenderingInstance) if (currentRenderingInstance.slots._ === 1) children._ = 1;
-			else {
-				children._ = 2;
-				vnode.patchFlag |= 1024;
-			}
-		}
-		else if (shared.isFunction(children)) {
-			children = {
-				default: children,
-				_ctx: currentRenderingInstance
-			};
-			type = 32;
-		} else {
-			children = String(children);
-			if (shapeFlag & 64) {
-				type = 16;
-				children = [createTextVNode(children)];
-			} else type = 8;
-		}
-		vnode.children = children;
-		vnode.shapeFlag |= type;
-	}
-	function mergeProps(...args) {
-		const ret = {};
-		for (let i = 0; i < args.length; i++) {
-			const toMerge = args[i];
-			for (const key in toMerge) if (key === "class") {
-				if (ret.class !== toMerge.class) ret.class = shared.normalizeClass([ret.class, toMerge.class]);
-			} else if (key === "style") ret.style = shared.normalizeStyle([ret.style, toMerge.style]);
-			else if (shared.isOn(key)) {
-				const existing = ret[key];
-				const incoming = toMerge[key];
-				if (incoming && existing !== incoming && !(shared.isArray(existing) && existing.includes(incoming))) ret[key] = existing ? [].concat(existing, incoming) : incoming;
-			} else if (key !== "") ret[key] = toMerge[key];
-		}
-		return ret;
-	}
-	function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
-		callWithAsyncErrorHandling(hook, instance, 7, [vnode, prevVNode]);
-	}
-	const emptyAppContext = createAppContext();
-	let uid = 0;
-	function createComponentInstance(vnode, parent, suspense) {
-		const type = vnode.type;
-		const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
-		const instance = {
-			uid: uid++,
-			vnode,
-			type,
-			parent,
-			appContext,
-			root: null,
-			next: null,
-			subTree: null,
-			effect: null,
-			update: null,
-			job: null,
-			scope: new reactivity.EffectScope(true),
-			render: null,
-			proxy: null,
-			exposed: null,
-			exposeProxy: null,
-			withProxy: null,
-			provides: parent ? parent.provides : Object.create(appContext.provides),
-			ids: parent ? parent.ids : [
-				"",
-				0,
-				0
-			],
-			accessCache: null,
-			renderCache: [],
-			components: null,
-			directives: null,
-			propsOptions: normalizePropsOptions(type, appContext),
-			emitsOptions: normalizeEmitsOptions(type, appContext),
-			emit: null,
-			emitted: null,
-			propsDefaults: shared.EMPTY_OBJ,
-			inheritAttrs: type.inheritAttrs,
-			ctx: shared.EMPTY_OBJ,
-			data: shared.EMPTY_OBJ,
-			props: shared.EMPTY_OBJ,
-			attrs: shared.EMPTY_OBJ,
-			slots: shared.EMPTY_OBJ,
-			refs: shared.EMPTY_OBJ,
-			setupState: shared.EMPTY_OBJ,
-			setupContext: null,
-			suspense,
-			suspenseId: suspense ? suspense.pendingId : 0,
-			asyncDep: null,
-			asyncResolved: false,
-			isMounted: false,
-			isUnmounted: false,
-			isDeactivated: false,
-			bc: null,
-			c: null,
-			bm: null,
-			m: null,
-			bu: null,
-			u: null,
-			um: null,
-			bum: null,
-			da: null,
-			a: null,
-			rtg: null,
-			rtc: null,
-			ec: null,
-			sp: null
-		};
-		instance.ctx = { _: instance };
-		instance.root = parent ? parent.root : instance;
-		instance.emit = emit.bind(null, instance);
-		if (vnode.ce) vnode.ce(instance);
-		return instance;
-	}
-	let currentInstance = null;
-	const getCurrentInstance = () => currentInstance || currentRenderingInstance;
-	let internalSetCurrentInstance;
-	let setInSSRSetupState;
-	{
-		const g = shared.getGlobalThis();
-		const registerGlobalSetter = (key, setter) => {
-			let setters;
-			if (!(setters = g[key])) setters = g[key] = [];
-			setters.push(setter);
-			return (v) => {
-				if (setters.length > 1) setters.forEach((set) => set(v));
-				else setters[0](v);
-			};
-		};
-		internalSetCurrentInstance = registerGlobalSetter(`__VUE_INSTANCE_SETTERS__`, (v) => currentInstance = v);
-		setInSSRSetupState = registerGlobalSetter(`__VUE_SSR_SETTERS__`, (v) => isInSSRComponentSetup = v);
-	}
-	const setCurrentInstance = (instance) => {
-		const prev = currentInstance;
-		internalSetCurrentInstance(instance);
-		instance.scope.on();
-		return () => {
-			instance.scope.off();
-			internalSetCurrentInstance(prev);
-		};
-	};
-	const unsetCurrentInstance = () => {
-		currentInstance && currentInstance.scope.off();
-		internalSetCurrentInstance(null);
-	};
-	function isStatefulComponent(instance) {
-		return instance.vnode.shapeFlag & 4;
-	}
-	let isInSSRComponentSetup = false;
-	function setupComponent(instance, isSSR = false, optimized = false) {
-		isSSR && setInSSRSetupState(isSSR);
-		const { props, children } = instance.vnode;
-		const isStateful = isStatefulComponent(instance);
-		initProps(instance, props, isStateful, isSSR);
-		initSlots(instance, children, optimized || isSSR);
-		const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
-		isSSR && setInSSRSetupState(false);
-		return setupResult;
-	}
-	function setupStatefulComponent(instance, isSSR) {
-		const Component = instance.type;
-		instance.accessCache = /* @__PURE__ */ Object.create(null);
-		instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
-		const { setup } = Component;
-		if (setup) {
-			reactivity.pauseTracking();
-			const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
-			const reset = setCurrentInstance(instance);
-			const setupResult = callWithErrorHandling(setup, instance, 0, [instance.props, setupContext]);
-			const isAsyncSetup = shared.isPromise(setupResult);
-			reactivity.resetTracking();
-			reset();
-			if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) markAsyncBoundary(instance);
-			if (isAsyncSetup) {
-				setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
-				if (isSSR) return setupResult.then((resolvedResult) => {
-					handleSetupResult(instance, resolvedResult, isSSR);
-				}).catch((e) => {
-					handleError(e, instance, 0);
-				});
-				else instance.asyncDep = setupResult;
-			} else handleSetupResult(instance, setupResult, isSSR);
-		} else finishComponentSetup(instance, isSSR);
-	}
-	function handleSetupResult(instance, setupResult, isSSR) {
-		if (shared.isFunction(setupResult)) if (instance.type.__ssrInlineRender) instance.ssrRender = setupResult;
-		else instance.render = setupResult;
-		else if (shared.isObject(setupResult)) instance.setupState = reactivity.proxyRefs(setupResult);
-		finishComponentSetup(instance, isSSR);
-	}
-	let compile;
-	let installWithProxy;
-	function registerRuntimeCompiler(_compile) {
-		compile = _compile;
-		installWithProxy = (i) => {
-			if (i.render._rc) i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
-		};
-	}
-	const isRuntimeOnly = () => !compile;
-	function finishComponentSetup(instance, isSSR, skipOptions) {
-		const Component = instance.type;
-		if (!instance.render) {
-			if (!isSSR && compile && !Component.render) {
-				const template = Component.template || resolveMergedOptions(instance).template;
-				if (template) {
-					const { isCustomElement, compilerOptions } = instance.appContext.config;
-					const { delimiters, compilerOptions: componentCompilerOptions } = Component;
-					const finalCompilerOptions = shared.extend(shared.extend({
-						isCustomElement,
-						delimiters
-					}, compilerOptions), componentCompilerOptions);
-					Component.render = compile(template, finalCompilerOptions);
-				}
-			}
-			instance.render = Component.render || shared.NOOP;
-			if (installWithProxy) installWithProxy(instance);
-		}
-		{
-			const reset = setCurrentInstance(instance);
-			reactivity.pauseTracking();
-			try {
-				applyOptions(instance);
-			} finally {
-				reactivity.resetTracking();
-				reset();
-			}
-		}
-	}
-	const attrsProxyHandlers = { get(target, key) {
-		reactivity.track(target, "get", "");
-		return target[key];
-	} };
-	function createSetupContext(instance) {
-		const expose = (exposed) => {
-			instance.exposed = exposed || {};
-		};
-		return {
-			attrs: new Proxy(instance.attrs, attrsProxyHandlers),
-			slots: instance.slots,
-			emit: instance.emit,
-			expose
-		};
-	}
-	function getComponentPublicInstance(instance) {
-		if (instance.exposed) return instance.exposeProxy || (instance.exposeProxy = new Proxy(reactivity.proxyRefs(reactivity.markRaw(instance.exposed)), {
-			get(target, key) {
-				if (key in target) return target[key];
-				else if (key in publicPropertiesMap) return publicPropertiesMap[key](instance);
-			},
-			has(target, key) {
-				return key in target || key in publicPropertiesMap;
-			}
-		}));
-		else return instance.proxy;
-	}
-	function getComponentName(Component, includeInferred = true) {
-		return shared.isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
-	}
-	function isClassComponent(value) {
-		return shared.isFunction(value) && "__vccOpts" in value;
-	}
-	const computed = (getterOrOptions, debugOptions) => {
-		return reactivity.computed(getterOrOptions, debugOptions, isInSSRComponentSetup);
-	};
-	function h(type, propsOrChildren, children) {
-		try {
-			setBlockTracking(-1);
-			const l = arguments.length;
-			if (l === 2) if (shared.isObject(propsOrChildren) && !shared.isArray(propsOrChildren)) {
-				if (isVNode(propsOrChildren)) return createVNode(type, null, [propsOrChildren]);
-				return createVNode(type, propsOrChildren);
-			} else return createVNode(type, null, propsOrChildren);
-			else {
-				if (l > 3) children = Array.prototype.slice.call(arguments, 2);
-				else if (l === 3 && isVNode(children)) children = [children];
-				return createVNode(type, propsOrChildren, children);
-			}
-		} finally {
-			setBlockTracking(1);
-		}
-	}
-	function initCustomFormatter() {}
-	function withMemo(memo, render, cache, index) {
-		const cached = cache[index];
-		if (cached && isMemoSame(cached, memo)) return cached;
-		const ret = render();
-		ret.memo = memo.slice();
-		ret.cacheIndex = index;
-		return cache[index] = ret;
-	}
-	function isMemoSame(cached, memo) {
-		const prev = cached.memo;
-		if (prev.length != memo.length) return false;
-		for (let i = 0; i < prev.length; i++) if (shared.hasChanged(prev[i], memo[i])) return false;
-		if (isBlockTreeEnabled > 0 && currentBlock) currentBlock.push(cached);
-		return true;
-	}
-	const version = "3.5.22";
-	const warn$1 = shared.NOOP;
-	const ErrorTypeStrings = ErrorTypeStrings$1;
-	const devtools = void 0;
-	const setDevtoolsHook = shared.NOOP;
-	const ssrUtils = {
-		createComponentInstance,
-		setupComponent,
-		renderComponentRoot,
-		setCurrentRenderingInstance,
-		isVNode,
-		normalizeVNode,
-		getComponentPublicInstance,
-		ensureValidVNode,
-		pushWarningContext,
-		popWarningContext
-	};
-	const resolveFilter = null;
-	const compatUtils = null;
-	const DeprecationTypes = null;
-	exports.EffectScope = reactivity.EffectScope;
-	exports.ReactiveEffect = reactivity.ReactiveEffect;
-	exports.TrackOpTypes = reactivity.TrackOpTypes;
-	exports.TriggerOpTypes = reactivity.TriggerOpTypes;
-	exports.customRef = reactivity.customRef;
-	exports.effect = reactivity.effect;
-	exports.effectScope = reactivity.effectScope;
-	exports.getCurrentScope = reactivity.getCurrentScope;
-	exports.getCurrentWatcher = reactivity.getCurrentWatcher;
-	exports.isProxy = reactivity.isProxy;
-	exports.isReactive = reactivity.isReactive;
-	exports.isReadonly = reactivity.isReadonly;
-	exports.isRef = reactivity.isRef;
-	exports.isShallow = reactivity.isShallow;
-	exports.markRaw = reactivity.markRaw;
-	exports.onScopeDispose = reactivity.onScopeDispose;
-	exports.onWatcherCleanup = reactivity.onWatcherCleanup;
-	exports.proxyRefs = reactivity.proxyRefs;
-	exports.reactive = reactivity.reactive;
-	exports.readonly = reactivity.readonly;
-	exports.ref = reactivity.ref;
-	exports.shallowReactive = reactivity.shallowReactive;
-	exports.shallowReadonly = reactivity.shallowReadonly;
-	exports.shallowRef = reactivity.shallowRef;
-	exports.stop = reactivity.stop;
-	exports.toRaw = reactivity.toRaw;
-	exports.toRef = reactivity.toRef;
-	exports.toRefs = reactivity.toRefs;
-	exports.toValue = reactivity.toValue;
-	exports.triggerRef = reactivity.triggerRef;
-	exports.unref = reactivity.unref;
-	exports.camelize = shared.camelize;
-	exports.capitalize = shared.capitalize;
-	exports.normalizeClass = shared.normalizeClass;
-	exports.normalizeProps = shared.normalizeProps;
-	exports.normalizeStyle = shared.normalizeStyle;
-	exports.toDisplayString = shared.toDisplayString;
-	exports.toHandlerKey = shared.toHandlerKey;
-	exports.BaseTransition = BaseTransition;
-	exports.BaseTransitionPropsValidators = BaseTransitionPropsValidators;
-	exports.Comment = Comment;
-	exports.DeprecationTypes = DeprecationTypes;
-	exports.ErrorCodes = ErrorCodes;
-	exports.ErrorTypeStrings = ErrorTypeStrings;
-	exports.Fragment = Fragment;
-	exports.KeepAlive = KeepAlive;
-	exports.Static = Static;
-	exports.Suspense = Suspense;
-	exports.Teleport = Teleport;
-	exports.Text = Text;
-	exports.assertNumber = assertNumber;
-	exports.callWithAsyncErrorHandling = callWithAsyncErrorHandling;
-	exports.callWithErrorHandling = callWithErrorHandling;
-	exports.cloneVNode = cloneVNode;
-	exports.compatUtils = compatUtils;
-	exports.computed = computed;
-	exports.createBlock = createBlock;
-	exports.createCommentVNode = createCommentVNode;
-	exports.createElementBlock = createElementBlock;
-	exports.createElementVNode = createBaseVNode;
-	exports.createHydrationRenderer = createHydrationRenderer;
-	exports.createPropsRestProxy = createPropsRestProxy;
-	exports.createRenderer = createRenderer;
-	exports.createSlots = createSlots;
-	exports.createStaticVNode = createStaticVNode;
-	exports.createTextVNode = createTextVNode;
-	exports.createVNode = createVNode;
-	exports.defineAsyncComponent = defineAsyncComponent;
-	exports.defineComponent = defineComponent;
-	exports.defineEmits = defineEmits;
-	exports.defineExpose = defineExpose;
-	exports.defineModel = defineModel;
-	exports.defineOptions = defineOptions;
-	exports.defineProps = defineProps;
-	exports.defineSlots = defineSlots;
-	exports.devtools = devtools;
-	exports.getCurrentInstance = getCurrentInstance;
-	exports.getTransitionRawChildren = getTransitionRawChildren;
-	exports.guardReactiveProps = guardReactiveProps;
-	exports.h = h;
-	exports.handleError = handleError;
-	exports.hasInjectionContext = hasInjectionContext;
-	exports.hydrateOnIdle = hydrateOnIdle;
-	exports.hydrateOnInteraction = hydrateOnInteraction;
-	exports.hydrateOnMediaQuery = hydrateOnMediaQuery;
-	exports.hydrateOnVisible = hydrateOnVisible;
-	exports.initCustomFormatter = initCustomFormatter;
-	exports.inject = inject;
-	exports.isMemoSame = isMemoSame;
-	exports.isRuntimeOnly = isRuntimeOnly;
-	exports.isVNode = isVNode;
-	exports.mergeDefaults = mergeDefaults;
-	exports.mergeModels = mergeModels;
-	exports.mergeProps = mergeProps;
-	exports.nextTick = nextTick;
-	exports.onActivated = onActivated;
-	exports.onBeforeMount = onBeforeMount;
-	exports.onBeforeUnmount = onBeforeUnmount;
-	exports.onBeforeUpdate = onBeforeUpdate;
-	exports.onDeactivated = onDeactivated;
-	exports.onErrorCaptured = onErrorCaptured;
-	exports.onMounted = onMounted;
-	exports.onRenderTracked = onRenderTracked;
-	exports.onRenderTriggered = onRenderTriggered;
-	exports.onServerPrefetch = onServerPrefetch;
-	exports.onUnmounted = onUnmounted;
-	exports.onUpdated = onUpdated;
-	exports.openBlock = openBlock;
-	exports.popScopeId = popScopeId;
-	exports.provide = provide;
-	exports.pushScopeId = pushScopeId;
-	exports.queuePostFlushCb = queuePostFlushCb;
-	exports.registerRuntimeCompiler = registerRuntimeCompiler;
-	exports.renderList = renderList;
-	exports.renderSlot = renderSlot;
-	exports.resolveComponent = resolveComponent;
-	exports.resolveDirective = resolveDirective;
-	exports.resolveDynamicComponent = resolveDynamicComponent;
-	exports.resolveFilter = resolveFilter;
-	exports.resolveTransitionHooks = resolveTransitionHooks;
-	exports.setBlockTracking = setBlockTracking;
-	exports.setDevtoolsHook = setDevtoolsHook;
-	exports.setTransitionHooks = setTransitionHooks;
-	exports.ssrContextKey = ssrContextKey;
-	exports.ssrUtils = ssrUtils;
-	exports.toHandlers = toHandlers;
-	exports.transformVNodeArgs = transformVNodeArgs;
-	exports.useAttrs = useAttrs;
-	exports.useId = useId;
-	exports.useModel = useModel;
-	exports.useSSRContext = useSSRContext;
-	exports.useSlots = useSlots;
-	exports.useTemplateRef = useTemplateRef;
-	exports.useTransitionState = useTransitionState;
-	exports.version = version;
-	exports.warn = warn$1;
-	exports.watch = watch;
-	exports.watchEffect = watchEffect;
-	exports.watchPostEffect = watchPostEffect;
-	exports.watchSyncEffect = watchSyncEffect;
-	exports.withAsyncContext = withAsyncContext;
-	exports.withCtx = withCtx;
-	exports.withDefaults = withDefaults;
-	exports.withDirectives = withDirectives;
-	exports.withMemo = withMemo;
-	exports.withScopeId = withScopeId;
-}) });
-
-//#endregion
-Object.defineProperty(exports, 'default', {
-  enumerable: true,
-  get: function () {
-    return require_runtime_core_cjs_prod();
-  }
-});
-//# sourceMappingURL=runtime-core.cjs.prod.cjs.map