nuxt-intlayer 7.0.0-canary.2 → 7.0.0

package/dist/esm/node_modules/.bun/@vue_compiler-core@3.5.22/node_modules/@vue/compiler-core/dist/compiler-core.cjs.prod.mjs

@@ -1,4748 +0,0 @@
-import { __commonJS } from "../../../../../../../_virtual/rolldown_runtime.mjs";
-import { require_shared } from "../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/index.mjs";
-import { require_decode } from "../../../../../entities@4.5.0/node_modules/entities/lib/decode.mjs";
-import { require_lib } from "../../../../../@babel_parser@7.28.4/node_modules/@babel/parser/lib/index.mjs";
-import { require_estree_walker } from "../../../../../estree-walker@2.0.2/node_modules/estree-walker/dist/umd/estree-walker.mjs";
-import { require_source_map } from "../../../../../source-map-js@1.2.1/node_modules/source-map-js/source-map.mjs";
-
-//#region ../../node_modules/.bun/@vue+compiler-core@3.5.22/node_modules/@vue/compiler-core/dist/compiler-core.cjs.prod.js
-var require_compiler_core_cjs_prod = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/@vue+compiler-core@3.5.22/node_modules/@vue/compiler-core/dist/compiler-core.cjs.prod.js": ((exports) => {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	var shared = require_shared();
-	var decode_js = require_decode();
-	var parser = require_lib();
-	var estreeWalker = require_estree_walker();
-	var sourceMapJs = require_source_map();
-	const FRAGMENT = Symbol(``);
-	const TELEPORT = Symbol(``);
-	const SUSPENSE = Symbol(``);
-	const KEEP_ALIVE = Symbol(``);
-	const BASE_TRANSITION = Symbol(``);
-	const OPEN_BLOCK = Symbol(``);
-	const CREATE_BLOCK = Symbol(``);
-	const CREATE_ELEMENT_BLOCK = Symbol(``);
-	const CREATE_VNODE = Symbol(``);
-	const CREATE_ELEMENT_VNODE = Symbol(``);
-	const CREATE_COMMENT = Symbol(``);
-	const CREATE_TEXT = Symbol(``);
-	const CREATE_STATIC = Symbol(``);
-	const RESOLVE_COMPONENT = Symbol(``);
-	const RESOLVE_DYNAMIC_COMPONENT = Symbol(``);
-	const RESOLVE_DIRECTIVE = Symbol(``);
-	const RESOLVE_FILTER = Symbol(``);
-	const WITH_DIRECTIVES = Symbol(``);
-	const RENDER_LIST = Symbol(``);
-	const RENDER_SLOT = Symbol(``);
-	const CREATE_SLOTS = Symbol(``);
-	const TO_DISPLAY_STRING = Symbol(``);
-	const MERGE_PROPS = Symbol(``);
-	const NORMALIZE_CLASS = Symbol(``);
-	const NORMALIZE_STYLE = Symbol(``);
-	const NORMALIZE_PROPS = Symbol(``);
-	const GUARD_REACTIVE_PROPS = Symbol(``);
-	const TO_HANDLERS = Symbol(``);
-	const CAMELIZE = Symbol(``);
-	const CAPITALIZE = Symbol(``);
-	const TO_HANDLER_KEY = Symbol(``);
-	const SET_BLOCK_TRACKING = Symbol(``);
-	const PUSH_SCOPE_ID = Symbol(``);
-	const POP_SCOPE_ID = Symbol(``);
-	const WITH_CTX = Symbol(``);
-	const UNREF = Symbol(``);
-	const IS_REF = Symbol(``);
-	const WITH_MEMO = Symbol(``);
-	const IS_MEMO_SAME = Symbol(``);
-	const helperNameMap = {
-		[FRAGMENT]: `Fragment`,
-		[TELEPORT]: `Teleport`,
-		[SUSPENSE]: `Suspense`,
-		[KEEP_ALIVE]: `KeepAlive`,
-		[BASE_TRANSITION]: `BaseTransition`,
-		[OPEN_BLOCK]: `openBlock`,
-		[CREATE_BLOCK]: `createBlock`,
-		[CREATE_ELEMENT_BLOCK]: `createElementBlock`,
-		[CREATE_VNODE]: `createVNode`,
-		[CREATE_ELEMENT_VNODE]: `createElementVNode`,
-		[CREATE_COMMENT]: `createCommentVNode`,
-		[CREATE_TEXT]: `createTextVNode`,
-		[CREATE_STATIC]: `createStaticVNode`,
-		[RESOLVE_COMPONENT]: `resolveComponent`,
-		[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
-		[RESOLVE_DIRECTIVE]: `resolveDirective`,
-		[RESOLVE_FILTER]: `resolveFilter`,
-		[WITH_DIRECTIVES]: `withDirectives`,
-		[RENDER_LIST]: `renderList`,
-		[RENDER_SLOT]: `renderSlot`,
-		[CREATE_SLOTS]: `createSlots`,
-		[TO_DISPLAY_STRING]: `toDisplayString`,
-		[MERGE_PROPS]: `mergeProps`,
-		[NORMALIZE_CLASS]: `normalizeClass`,
-		[NORMALIZE_STYLE]: `normalizeStyle`,
-		[NORMALIZE_PROPS]: `normalizeProps`,
-		[GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
-		[TO_HANDLERS]: `toHandlers`,
-		[CAMELIZE]: `camelize`,
-		[CAPITALIZE]: `capitalize`,
-		[TO_HANDLER_KEY]: `toHandlerKey`,
-		[SET_BLOCK_TRACKING]: `setBlockTracking`,
-		[PUSH_SCOPE_ID]: `pushScopeId`,
-		[POP_SCOPE_ID]: `popScopeId`,
-		[WITH_CTX]: `withCtx`,
-		[UNREF]: `unref`,
-		[IS_REF]: `isRef`,
-		[WITH_MEMO]: `withMemo`,
-		[IS_MEMO_SAME]: `isMemoSame`
-	};
-	function registerRuntimeHelpers(helpers) {
-		Object.getOwnPropertySymbols(helpers).forEach((s) => {
-			helperNameMap[s] = helpers[s];
-		});
-	}
-	const Namespaces = {
-		"HTML": 0,
-		"0": "HTML",
-		"SVG": 1,
-		"1": "SVG",
-		"MATH_ML": 2,
-		"2": "MATH_ML"
-	};
-	const NodeTypes = {
-		"ROOT": 0,
-		"0": "ROOT",
-		"ELEMENT": 1,
-		"1": "ELEMENT",
-		"TEXT": 2,
-		"2": "TEXT",
-		"COMMENT": 3,
-		"3": "COMMENT",
-		"SIMPLE_EXPRESSION": 4,
-		"4": "SIMPLE_EXPRESSION",
-		"INTERPOLATION": 5,
-		"5": "INTERPOLATION",
-		"ATTRIBUTE": 6,
-		"6": "ATTRIBUTE",
-		"DIRECTIVE": 7,
-		"7": "DIRECTIVE",
-		"COMPOUND_EXPRESSION": 8,
-		"8": "COMPOUND_EXPRESSION",
-		"IF": 9,
-		"9": "IF",
-		"IF_BRANCH": 10,
-		"10": "IF_BRANCH",
-		"FOR": 11,
-		"11": "FOR",
-		"TEXT_CALL": 12,
-		"12": "TEXT_CALL",
-		"VNODE_CALL": 13,
-		"13": "VNODE_CALL",
-		"JS_CALL_EXPRESSION": 14,
-		"14": "JS_CALL_EXPRESSION",
-		"JS_OBJECT_EXPRESSION": 15,
-		"15": "JS_OBJECT_EXPRESSION",
-		"JS_PROPERTY": 16,
-		"16": "JS_PROPERTY",
-		"JS_ARRAY_EXPRESSION": 17,
-		"17": "JS_ARRAY_EXPRESSION",
-		"JS_FUNCTION_EXPRESSION": 18,
-		"18": "JS_FUNCTION_EXPRESSION",
-		"JS_CONDITIONAL_EXPRESSION": 19,
-		"19": "JS_CONDITIONAL_EXPRESSION",
-		"JS_CACHE_EXPRESSION": 20,
-		"20": "JS_CACHE_EXPRESSION",
-		"JS_BLOCK_STATEMENT": 21,
-		"21": "JS_BLOCK_STATEMENT",
-		"JS_TEMPLATE_LITERAL": 22,
-		"22": "JS_TEMPLATE_LITERAL",
-		"JS_IF_STATEMENT": 23,
-		"23": "JS_IF_STATEMENT",
-		"JS_ASSIGNMENT_EXPRESSION": 24,
-		"24": "JS_ASSIGNMENT_EXPRESSION",
-		"JS_SEQUENCE_EXPRESSION": 25,
-		"25": "JS_SEQUENCE_EXPRESSION",
-		"JS_RETURN_STATEMENT": 26,
-		"26": "JS_RETURN_STATEMENT"
-	};
-	const ElementTypes = {
-		"ELEMENT": 0,
-		"0": "ELEMENT",
-		"COMPONENT": 1,
-		"1": "COMPONENT",
-		"SLOT": 2,
-		"2": "SLOT",
-		"TEMPLATE": 3,
-		"3": "TEMPLATE"
-	};
-	const ConstantTypes = {
-		"NOT_CONSTANT": 0,
-		"0": "NOT_CONSTANT",
-		"CAN_SKIP_PATCH": 1,
-		"1": "CAN_SKIP_PATCH",
-		"CAN_CACHE": 2,
-		"2": "CAN_CACHE",
-		"CAN_STRINGIFY": 3,
-		"3": "CAN_STRINGIFY"
-	};
-	const locStub = {
-		start: {
-			line: 1,
-			column: 1,
-			offset: 0
-		},
-		end: {
-			line: 1,
-			column: 1,
-			offset: 0
-		},
-		source: ""
-	};
-	function createRoot(children, source = "") {
-		return {
-			type: 0,
-			source,
-			children,
-			helpers: /* @__PURE__ */ new Set(),
-			components: [],
-			directives: [],
-			hoists: [],
-			imports: [],
-			cached: [],
-			temps: 0,
-			codegenNode: void 0,
-			loc: locStub
-		};
-	}
-	function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent$1 = false, loc = locStub) {
-		if (context) {
-			if (isBlock) {
-				context.helper(OPEN_BLOCK);
-				context.helper(getVNodeBlockHelper(context.inSSR, isComponent$1));
-			} else context.helper(getVNodeHelper(context.inSSR, isComponent$1));
-			if (directives) context.helper(WITH_DIRECTIVES);
-		}
-		return {
-			type: 13,
-			tag,
-			props,
-			children,
-			patchFlag,
-			dynamicProps,
-			directives,
-			isBlock,
-			disableTracking,
-			isComponent: isComponent$1,
-			loc
-		};
-	}
-	function createArrayExpression(elements, loc = locStub) {
-		return {
-			type: 17,
-			loc,
-			elements
-		};
-	}
-	function createObjectExpression(properties, loc = locStub) {
-		return {
-			type: 15,
-			loc,
-			properties
-		};
-	}
-	function createObjectProperty(key, value) {
-		return {
-			type: 16,
-			loc: locStub,
-			key: shared.isString(key) ? createSimpleExpression(key, true) : key,
-			value
-		};
-	}
-	function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
-		return {
-			type: 4,
-			loc,
-			content,
-			isStatic,
-			constType: isStatic ? 3 : constType
-		};
-	}
-	function createInterpolation(content, loc) {
-		return {
-			type: 5,
-			loc,
-			content: shared.isString(content) ? createSimpleExpression(content, false, loc) : content
-		};
-	}
-	function createCompoundExpression(children, loc = locStub) {
-		return {
-			type: 8,
-			loc,
-			children
-		};
-	}
-	function createCallExpression(callee, args = [], loc = locStub) {
-		return {
-			type: 14,
-			loc,
-			callee,
-			arguments: args
-		};
-	}
-	function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
-		return {
-			type: 18,
-			params,
-			returns,
-			newline,
-			isSlot,
-			loc
-		};
-	}
-	function createConditionalExpression(test, consequent, alternate, newline = true) {
-		return {
-			type: 19,
-			test,
-			consequent,
-			alternate,
-			newline,
-			loc: locStub
-		};
-	}
-	function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {
-		return {
-			type: 20,
-			index,
-			value,
-			needPauseTracking,
-			inVOnce,
-			needArraySpread: false,
-			loc: locStub
-		};
-	}
-	function createBlockStatement(body) {
-		return {
-			type: 21,
-			body,
-			loc: locStub
-		};
-	}
-	function createTemplateLiteral(elements) {
-		return {
-			type: 22,
-			elements,
-			loc: locStub
-		};
-	}
-	function createIfStatement(test, consequent, alternate) {
-		return {
-			type: 23,
-			test,
-			consequent,
-			alternate,
-			loc: locStub
-		};
-	}
-	function createAssignmentExpression(left, right) {
-		return {
-			type: 24,
-			left,
-			right,
-			loc: locStub
-		};
-	}
-	function createSequenceExpression(expressions) {
-		return {
-			type: 25,
-			expressions,
-			loc: locStub
-		};
-	}
-	function createReturnStatement(returns) {
-		return {
-			type: 26,
-			returns,
-			loc: locStub
-		};
-	}
-	function getVNodeHelper(ssr, isComponent$1) {
-		return ssr || isComponent$1 ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
-	}
-	function getVNodeBlockHelper(ssr, isComponent$1) {
-		return ssr || isComponent$1 ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
-	}
-	function convertToBlock(node, { helper, removeHelper, inSSR }) {
-		if (!node.isBlock) {
-			node.isBlock = true;
-			removeHelper(getVNodeHelper(inSSR, node.isComponent));
-			helper(OPEN_BLOCK);
-			helper(getVNodeBlockHelper(inSSR, node.isComponent));
-		}
-	}
-	const defaultDelimitersOpen = new Uint8Array([123, 123]);
-	const defaultDelimitersClose = new Uint8Array([125, 125]);
-	function isTagStartChar(c) {
-		return c >= 97 && c <= 122 || c >= 65 && c <= 90;
-	}
-	function isWhitespace(c) {
-		return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
-	}
-	function isEndOfTagSection(c) {
-		return c === 47 || c === 62 || isWhitespace(c);
-	}
-	function toCharCodes(str) {
-		const ret = new Uint8Array(str.length);
-		for (let i = 0; i < str.length; i++) ret[i] = str.charCodeAt(i);
-		return ret;
-	}
-	const Sequences = {
-		Cdata: new Uint8Array([
-			67,
-			68,
-			65,
-			84,
-			65,
-			91
-		]),
-		CdataEnd: new Uint8Array([
-			93,
-			93,
-			62
-		]),
-		CommentEnd: new Uint8Array([
-			45,
-			45,
-			62
-		]),
-		ScriptEnd: new Uint8Array([
-			60,
-			47,
-			115,
-			99,
-			114,
-			105,
-			112,
-			116
-		]),
-		StyleEnd: new Uint8Array([
-			60,
-			47,
-			115,
-			116,
-			121,
-			108,
-			101
-		]),
-		TitleEnd: new Uint8Array([
-			60,
-			47,
-			116,
-			105,
-			116,
-			108,
-			101
-		]),
-		TextareaEnd: new Uint8Array([
-			60,
-			47,
-			116,
-			101,
-			120,
-			116,
-			97,
-			114,
-			101,
-			97
-		])
-	};
-	var Tokenizer = class {
-		constructor(stack$1, cbs) {
-			this.stack = stack$1;
-			this.cbs = cbs;
-			/** The current state the tokenizer is in. */
-			this.state = 1;
-			/** The read buffer. */
-			this.buffer = "";
-			/** The beginning of the section that is currently being read. */
-			this.sectionStart = 0;
-			/** The index within the buffer that we are currently looking at. */
-			this.index = 0;
-			/** The start of the last entity. */
-			this.entityStart = 0;
-			/** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
-			this.baseState = 1;
-			/** For special parsing behavior inside of script and style tags. */
-			this.inRCDATA = false;
-			/** For disabling RCDATA tags handling */
-			this.inXML = false;
-			/** For disabling interpolation parsing in v-pre */
-			this.inVPre = false;
-			/** Record newline positions for fast line / column calculation */
-			this.newlines = [];
-			this.mode = 0;
-			this.delimiterOpen = defaultDelimitersOpen;
-			this.delimiterClose = defaultDelimitersClose;
-			this.delimiterIndex = -1;
-			this.currentSequence = void 0;
-			this.sequenceIndex = 0;
-			this.entityDecoder = new decode_js.EntityDecoder(decode_js.htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));
-		}
-		get inSFCRoot() {
-			return this.mode === 2 && this.stack.length === 0;
-		}
-		reset() {
-			this.state = 1;
-			this.mode = 0;
-			this.buffer = "";
-			this.sectionStart = 0;
-			this.index = 0;
-			this.baseState = 1;
-			this.inRCDATA = false;
-			this.currentSequence = void 0;
-			this.newlines.length = 0;
-			this.delimiterOpen = defaultDelimitersOpen;
-			this.delimiterClose = defaultDelimitersClose;
-		}
-		/**
-		* Generate Position object with line / column information using recorded
-		* newline positions. We know the index is always going to be an already
-		* processed index, so all the newlines up to this index should have been
-		* recorded.
-		*/
-		getPos(index) {
-			let line = 1;
-			let column = index + 1;
-			for (let i = this.newlines.length - 1; i >= 0; i--) {
-				const newlineIndex = this.newlines[i];
-				if (index > newlineIndex) {
-					line = i + 2;
-					column = index - newlineIndex;
-					break;
-				}
-			}
-			return {
-				column,
-				line,
-				offset: index
-			};
-		}
-		peek() {
-			return this.buffer.charCodeAt(this.index + 1);
-		}
-		stateText(c) {
-			if (c === 60) {
-				if (this.index > this.sectionStart) this.cbs.ontext(this.sectionStart, this.index);
-				this.state = 5;
-				this.sectionStart = this.index;
-			} else if (c === 38) this.startEntity();
-			else if (!this.inVPre && c === this.delimiterOpen[0]) {
-				this.state = 2;
-				this.delimiterIndex = 0;
-				this.stateInterpolationOpen(c);
-			}
-		}
-		stateInterpolationOpen(c) {
-			if (c === this.delimiterOpen[this.delimiterIndex]) if (this.delimiterIndex === this.delimiterOpen.length - 1) {
-				const start = this.index + 1 - this.delimiterOpen.length;
-				if (start > this.sectionStart) this.cbs.ontext(this.sectionStart, start);
-				this.state = 3;
-				this.sectionStart = start;
-			} else this.delimiterIndex++;
-			else if (this.inRCDATA) {
-				this.state = 32;
-				this.stateInRCDATA(c);
-			} else {
-				this.state = 1;
-				this.stateText(c);
-			}
-		}
-		stateInterpolation(c) {
-			if (c === this.delimiterClose[0]) {
-				this.state = 4;
-				this.delimiterIndex = 0;
-				this.stateInterpolationClose(c);
-			}
-		}
-		stateInterpolationClose(c) {
-			if (c === this.delimiterClose[this.delimiterIndex]) if (this.delimiterIndex === this.delimiterClose.length - 1) {
-				this.cbs.oninterpolation(this.sectionStart, this.index + 1);
-				if (this.inRCDATA) this.state = 32;
-				else this.state = 1;
-				this.sectionStart = this.index + 1;
-			} else this.delimiterIndex++;
-			else {
-				this.state = 3;
-				this.stateInterpolation(c);
-			}
-		}
-		stateSpecialStartSequence(c) {
-			const isEnd = this.sequenceIndex === this.currentSequence.length;
-			if (!(isEnd ? isEndOfTagSection(c) : (c | 32) === this.currentSequence[this.sequenceIndex])) this.inRCDATA = false;
-			else if (!isEnd) {
-				this.sequenceIndex++;
-				return;
-			}
-			this.sequenceIndex = 0;
-			this.state = 6;
-			this.stateInTagName(c);
-		}
-		/** Look for an end tag. For <title> and <textarea>, also decode entities. */
-		stateInRCDATA(c) {
-			if (this.sequenceIndex === this.currentSequence.length) {
-				if (c === 62 || isWhitespace(c)) {
-					const endOfText = this.index - this.currentSequence.length;
-					if (this.sectionStart < endOfText) {
-						const actualIndex = this.index;
-						this.index = endOfText;
-						this.cbs.ontext(this.sectionStart, endOfText);
-						this.index = actualIndex;
-					}
-					this.sectionStart = endOfText + 2;
-					this.stateInClosingTagName(c);
-					this.inRCDATA = false;
-					return;
-				}
-				this.sequenceIndex = 0;
-			}
-			if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;
-			else if (this.sequenceIndex === 0) {
-				if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
-					if (c === 38) this.startEntity();
-					else if (!this.inVPre && c === this.delimiterOpen[0]) {
-						this.state = 2;
-						this.delimiterIndex = 0;
-						this.stateInterpolationOpen(c);
-					}
-				} else if (this.fastForwardTo(60)) this.sequenceIndex = 1;
-			} else this.sequenceIndex = Number(c === 60);
-		}
-		stateCDATASequence(c) {
-			if (c === Sequences.Cdata[this.sequenceIndex]) {
-				if (++this.sequenceIndex === Sequences.Cdata.length) {
-					this.state = 28;
-					this.currentSequence = Sequences.CdataEnd;
-					this.sequenceIndex = 0;
-					this.sectionStart = this.index + 1;
-				}
-			} else {
-				this.sequenceIndex = 0;
-				this.state = 23;
-				this.stateInDeclaration(c);
-			}
-		}
-		/**
-		* When we wait for one specific character, we can speed things up
-		* by skipping through the buffer until we find it.
-		*
-		* @returns Whether the character was found.
-		*/
-		fastForwardTo(c) {
-			while (++this.index < this.buffer.length) {
-				const cc = this.buffer.charCodeAt(this.index);
-				if (cc === 10) this.newlines.push(this.index);
-				if (cc === c) return true;
-			}
-			this.index = this.buffer.length - 1;
-			return false;
-		}
-		/**
-		* Comments and CDATA end with `-->` and `]]>`.
-		*
-		* Their common qualities are:
-		* - Their end sequences have a distinct character they start with.
-		* - That character is then repeated, so we have to check multiple repeats.
-		* - All characters but the start character of the sequence can be skipped.
-		*/
-		stateInCommentLike(c) {
-			if (c === this.currentSequence[this.sequenceIndex]) {
-				if (++this.sequenceIndex === this.currentSequence.length) {
-					if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, this.index - 2);
-					else this.cbs.oncomment(this.sectionStart, this.index - 2);
-					this.sequenceIndex = 0;
-					this.sectionStart = this.index + 1;
-					this.state = 1;
-				}
-			} else if (this.sequenceIndex === 0) {
-				if (this.fastForwardTo(this.currentSequence[0])) this.sequenceIndex = 1;
-			} else if (c !== this.currentSequence[this.sequenceIndex - 1]) this.sequenceIndex = 0;
-		}
-		startSpecial(sequence, offset) {
-			this.enterRCDATA(sequence, offset);
-			this.state = 31;
-		}
-		enterRCDATA(sequence, offset) {
-			this.inRCDATA = true;
-			this.currentSequence = sequence;
-			this.sequenceIndex = offset;
-		}
-		stateBeforeTagName(c) {
-			if (c === 33) {
-				this.state = 22;
-				this.sectionStart = this.index + 1;
-			} else if (c === 63) {
-				this.state = 24;
-				this.sectionStart = this.index + 1;
-			} else if (isTagStartChar(c)) {
-				this.sectionStart = this.index;
-				if (this.mode === 0) this.state = 6;
-				else if (this.inSFCRoot) this.state = 34;
-				else if (!this.inXML) if (c === 116) this.state = 30;
-				else this.state = c === 115 ? 29 : 6;
-				else this.state = 6;
-			} else if (c === 47) this.state = 8;
-			else {
-				this.state = 1;
-				this.stateText(c);
-			}
-		}
-		stateInTagName(c) {
-			if (isEndOfTagSection(c)) this.handleTagName(c);
-		}
-		stateInSFCRootTagName(c) {
-			if (isEndOfTagSection(c)) {
-				const tag = this.buffer.slice(this.sectionStart, this.index);
-				if (tag !== "template") this.enterRCDATA(toCharCodes(`</` + tag), 0);
-				this.handleTagName(c);
-			}
-		}
-		handleTagName(c) {
-			this.cbs.onopentagname(this.sectionStart, this.index);
-			this.sectionStart = -1;
-			this.state = 11;
-			this.stateBeforeAttrName(c);
-		}
-		stateBeforeClosingTagName(c) {
-			if (isWhitespace(c));
-			else if (c === 62) {
-				this.cbs.onerr(14, this.index);
-				this.state = 1;
-				this.sectionStart = this.index + 1;
-			} else {
-				this.state = isTagStartChar(c) ? 9 : 27;
-				this.sectionStart = this.index;
-			}
-		}
-		stateInClosingTagName(c) {
-			if (c === 62 || isWhitespace(c)) {
-				this.cbs.onclosetag(this.sectionStart, this.index);
-				this.sectionStart = -1;
-				this.state = 10;
-				this.stateAfterClosingTagName(c);
-			}
-		}
-		stateAfterClosingTagName(c) {
-			if (c === 62) {
-				this.state = 1;
-				this.sectionStart = this.index + 1;
-			}
-		}
-		stateBeforeAttrName(c) {
-			if (c === 62) {
-				this.cbs.onopentagend(this.index);
-				if (this.inRCDATA) this.state = 32;
-				else this.state = 1;
-				this.sectionStart = this.index + 1;
-			} else if (c === 47) {
-				this.state = 7;
-				if (this.peek() !== 62) this.cbs.onerr(22, this.index);
-			} else if (c === 60 && this.peek() === 47) {
-				this.cbs.onopentagend(this.index);
-				this.state = 5;
-				this.sectionStart = this.index;
-			} else if (!isWhitespace(c)) {
-				if (c === 61) this.cbs.onerr(19, this.index);
-				this.handleAttrStart(c);
-			}
-		}
-		handleAttrStart(c) {
-			if (c === 118 && this.peek() === 45) {
-				this.state = 13;
-				this.sectionStart = this.index;
-			} else if (c === 46 || c === 58 || c === 64 || c === 35) {
-				this.cbs.ondirname(this.index, this.index + 1);
-				this.state = 14;
-				this.sectionStart = this.index + 1;
-			} else {
-				this.state = 12;
-				this.sectionStart = this.index;
-			}
-		}
-		stateInSelfClosingTag(c) {
-			if (c === 62) {
-				this.cbs.onselfclosingtag(this.index);
-				this.state = 1;
-				this.sectionStart = this.index + 1;
-				this.inRCDATA = false;
-			} else if (!isWhitespace(c)) {
-				this.state = 11;
-				this.stateBeforeAttrName(c);
-			}
-		}
-		stateInAttrName(c) {
-			if (c === 61 || isEndOfTagSection(c)) {
-				this.cbs.onattribname(this.sectionStart, this.index);
-				this.handleAttrNameEnd(c);
-			} else if (c === 34 || c === 39 || c === 60) this.cbs.onerr(17, this.index);
-		}
-		stateInDirName(c) {
-			if (c === 61 || isEndOfTagSection(c)) {
-				this.cbs.ondirname(this.sectionStart, this.index);
-				this.handleAttrNameEnd(c);
-			} else if (c === 58) {
-				this.cbs.ondirname(this.sectionStart, this.index);
-				this.state = 14;
-				this.sectionStart = this.index + 1;
-			} else if (c === 46) {
-				this.cbs.ondirname(this.sectionStart, this.index);
-				this.state = 16;
-				this.sectionStart = this.index + 1;
-			}
-		}
-		stateInDirArg(c) {
-			if (c === 61 || isEndOfTagSection(c)) {
-				this.cbs.ondirarg(this.sectionStart, this.index);
-				this.handleAttrNameEnd(c);
-			} else if (c === 91) this.state = 15;
-			else if (c === 46) {
-				this.cbs.ondirarg(this.sectionStart, this.index);
-				this.state = 16;
-				this.sectionStart = this.index + 1;
-			}
-		}
-		stateInDynamicDirArg(c) {
-			if (c === 93) this.state = 14;
-			else if (c === 61 || isEndOfTagSection(c)) {
-				this.cbs.ondirarg(this.sectionStart, this.index + 1);
-				this.handleAttrNameEnd(c);
-				this.cbs.onerr(27, this.index);
-			}
-		}
-		stateInDirModifier(c) {
-			if (c === 61 || isEndOfTagSection(c)) {
-				this.cbs.ondirmodifier(this.sectionStart, this.index);
-				this.handleAttrNameEnd(c);
-			} else if (c === 46) {
-				this.cbs.ondirmodifier(this.sectionStart, this.index);
-				this.sectionStart = this.index + 1;
-			}
-		}
-		handleAttrNameEnd(c) {
-			this.sectionStart = this.index;
-			this.state = 17;
-			this.cbs.onattribnameend(this.index);
-			this.stateAfterAttrName(c);
-		}
-		stateAfterAttrName(c) {
-			if (c === 61) this.state = 18;
-			else if (c === 47 || c === 62) {
-				this.cbs.onattribend(0, this.sectionStart);
-				this.sectionStart = -1;
-				this.state = 11;
-				this.stateBeforeAttrName(c);
-			} else if (!isWhitespace(c)) {
-				this.cbs.onattribend(0, this.sectionStart);
-				this.handleAttrStart(c);
-			}
-		}
-		stateBeforeAttrValue(c) {
-			if (c === 34) {
-				this.state = 19;
-				this.sectionStart = this.index + 1;
-			} else if (c === 39) {
-				this.state = 20;
-				this.sectionStart = this.index + 1;
-			} else if (!isWhitespace(c)) {
-				this.sectionStart = this.index;
-				this.state = 21;
-				this.stateInAttrValueNoQuotes(c);
-			}
-		}
-		handleInAttrValue(c, quote) {
-			if (c === quote || false) {
-				this.cbs.onattribdata(this.sectionStart, this.index);
-				this.sectionStart = -1;
-				this.cbs.onattribend(quote === 34 ? 3 : 2, this.index + 1);
-				this.state = 11;
-			} else if (c === 38) this.startEntity();
-		}
-		stateInAttrValueDoubleQuotes(c) {
-			this.handleInAttrValue(c, 34);
-		}
-		stateInAttrValueSingleQuotes(c) {
-			this.handleInAttrValue(c, 39);
-		}
-		stateInAttrValueNoQuotes(c) {
-			if (isWhitespace(c) || c === 62) {
-				this.cbs.onattribdata(this.sectionStart, this.index);
-				this.sectionStart = -1;
-				this.cbs.onattribend(1, this.index);
-				this.state = 11;
-				this.stateBeforeAttrName(c);
-			} else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) this.cbs.onerr(18, this.index);
-			else if (c === 38) this.startEntity();
-		}
-		stateBeforeDeclaration(c) {
-			if (c === 91) {
-				this.state = 26;
-				this.sequenceIndex = 0;
-			} else this.state = c === 45 ? 25 : 23;
-		}
-		stateInDeclaration(c) {
-			if (c === 62 || this.fastForwardTo(62)) {
-				this.state = 1;
-				this.sectionStart = this.index + 1;
-			}
-		}
-		stateInProcessingInstruction(c) {
-			if (c === 62 || this.fastForwardTo(62)) {
-				this.cbs.onprocessinginstruction(this.sectionStart, this.index);
-				this.state = 1;
-				this.sectionStart = this.index + 1;
-			}
-		}
-		stateBeforeComment(c) {
-			if (c === 45) {
-				this.state = 28;
-				this.currentSequence = Sequences.CommentEnd;
-				this.sequenceIndex = 2;
-				this.sectionStart = this.index + 1;
-			} else this.state = 23;
-		}
-		stateInSpecialComment(c) {
-			if (c === 62 || this.fastForwardTo(62)) {
-				this.cbs.oncomment(this.sectionStart, this.index);
-				this.state = 1;
-				this.sectionStart = this.index + 1;
-			}
-		}
-		stateBeforeSpecialS(c) {
-			if (c === Sequences.ScriptEnd[3]) this.startSpecial(Sequences.ScriptEnd, 4);
-			else if (c === Sequences.StyleEnd[3]) this.startSpecial(Sequences.StyleEnd, 4);
-			else {
-				this.state = 6;
-				this.stateInTagName(c);
-			}
-		}
-		stateBeforeSpecialT(c) {
-			if (c === Sequences.TitleEnd[3]) this.startSpecial(Sequences.TitleEnd, 4);
-			else if (c === Sequences.TextareaEnd[3]) this.startSpecial(Sequences.TextareaEnd, 4);
-			else {
-				this.state = 6;
-				this.stateInTagName(c);
-			}
-		}
-		startEntity() {
-			this.baseState = this.state;
-			this.state = 33;
-			this.entityStart = this.index;
-			this.entityDecoder.startEntity(this.baseState === 1 || this.baseState === 32 ? decode_js.DecodingMode.Legacy : decode_js.DecodingMode.Attribute);
-		}
-		stateInEntity() {
-			{
-				const length = this.entityDecoder.write(this.buffer, this.index);
-				if (length >= 0) {
-					this.state = this.baseState;
-					if (length === 0) this.index = this.entityStart;
-				} else this.index = this.buffer.length - 1;
-			}
-		}
-		/**
-		* Iterates through the buffer, calling the function corresponding to the current state.
-		*
-		* States that are more likely to be hit are higher up, as a performance improvement.
-		*/
-		parse(input) {
-			this.buffer = input;
-			while (this.index < this.buffer.length) {
-				const c = this.buffer.charCodeAt(this.index);
-				if (c === 10 && this.state !== 33) this.newlines.push(this.index);
-				switch (this.state) {
-					case 1:
-						this.stateText(c);
-						break;
-					case 2:
-						this.stateInterpolationOpen(c);
-						break;
-					case 3:
-						this.stateInterpolation(c);
-						break;
-					case 4:
-						this.stateInterpolationClose(c);
-						break;
-					case 31:
-						this.stateSpecialStartSequence(c);
-						break;
-					case 32:
-						this.stateInRCDATA(c);
-						break;
-					case 26:
-						this.stateCDATASequence(c);
-						break;
-					case 19:
-						this.stateInAttrValueDoubleQuotes(c);
-						break;
-					case 12:
-						this.stateInAttrName(c);
-						break;
-					case 13:
-						this.stateInDirName(c);
-						break;
-					case 14:
-						this.stateInDirArg(c);
-						break;
-					case 15:
-						this.stateInDynamicDirArg(c);
-						break;
-					case 16:
-						this.stateInDirModifier(c);
-						break;
-					case 28:
-						this.stateInCommentLike(c);
-						break;
-					case 27:
-						this.stateInSpecialComment(c);
-						break;
-					case 11:
-						this.stateBeforeAttrName(c);
-						break;
-					case 6:
-						this.stateInTagName(c);
-						break;
-					case 34:
-						this.stateInSFCRootTagName(c);
-						break;
-					case 9:
-						this.stateInClosingTagName(c);
-						break;
-					case 5:
-						this.stateBeforeTagName(c);
-						break;
-					case 17:
-						this.stateAfterAttrName(c);
-						break;
-					case 20:
-						this.stateInAttrValueSingleQuotes(c);
-						break;
-					case 18:
-						this.stateBeforeAttrValue(c);
-						break;
-					case 8:
-						this.stateBeforeClosingTagName(c);
-						break;
-					case 10:
-						this.stateAfterClosingTagName(c);
-						break;
-					case 29:
-						this.stateBeforeSpecialS(c);
-						break;
-					case 30:
-						this.stateBeforeSpecialT(c);
-						break;
-					case 21:
-						this.stateInAttrValueNoQuotes(c);
-						break;
-					case 7:
-						this.stateInSelfClosingTag(c);
-						break;
-					case 23:
-						this.stateInDeclaration(c);
-						break;
-					case 22:
-						this.stateBeforeDeclaration(c);
-						break;
-					case 25:
-						this.stateBeforeComment(c);
-						break;
-					case 24:
-						this.stateInProcessingInstruction(c);
-						break;
-					case 33:
-						this.stateInEntity();
-						break;
-				}
-				this.index++;
-			}
-			this.cleanup();
-			this.finish();
-		}
-		/**
-		* Remove data that has already been consumed from the buffer.
-		*/
-		cleanup() {
-			if (this.sectionStart !== this.index) {
-				if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
-					this.cbs.ontext(this.sectionStart, this.index);
-					this.sectionStart = this.index;
-				} else if (this.state === 19 || this.state === 20 || this.state === 21) {
-					this.cbs.onattribdata(this.sectionStart, this.index);
-					this.sectionStart = this.index;
-				}
-			}
-		}
-		finish() {
-			if (this.state === 33) {
-				this.entityDecoder.end();
-				this.state = this.baseState;
-			}
-			this.handleTrailingData();
-			this.cbs.onend();
-		}
-		/** Handle any trailing data. */
-		handleTrailingData() {
-			const endIndex = this.buffer.length;
-			if (this.sectionStart >= endIndex) return;
-			if (this.state === 28) if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, endIndex);
-			else this.cbs.oncomment(this.sectionStart, endIndex);
-			else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9);
-			else this.cbs.ontext(this.sectionStart, endIndex);
-		}
-		emitCodePoint(cp, consumed) {
-			if (this.baseState !== 1 && this.baseState !== 32) {
-				if (this.sectionStart < this.entityStart) this.cbs.onattribdata(this.sectionStart, this.entityStart);
-				this.sectionStart = this.entityStart + consumed;
-				this.index = this.sectionStart - 1;
-				this.cbs.onattribentity(decode_js.fromCodePoint(cp), this.entityStart, this.sectionStart);
-			} else {
-				if (this.sectionStart < this.entityStart) this.cbs.ontext(this.sectionStart, this.entityStart);
-				this.sectionStart = this.entityStart + consumed;
-				this.index = this.sectionStart - 1;
-				this.cbs.ontextentity(decode_js.fromCodePoint(cp), this.entityStart, this.sectionStart);
-			}
-		}
-	};
-	const CompilerDeprecationTypes = {
-		"COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
-		"COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
-		"COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
-		"COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
-		"COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
-		"COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
-		"COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
-		"COMPILER_FILTERS": "COMPILER_FILTERS"
-	};
-	const deprecationData = {
-		["COMPILER_IS_ON_ELEMENT"]: {
-			message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
-		},
-		["COMPILER_V_BIND_SYNC"]: {
-			message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
-		},
-		["COMPILER_V_BIND_OBJECT_ORDER"]: {
-			message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
-		},
-		["COMPILER_V_ON_NATIVE"]: {
-			message: `.native modifier for v-on has been removed as is no longer necessary.`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
-		},
-		["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
-			message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
-		},
-		["COMPILER_NATIVE_TEMPLATE"]: { message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.` },
-		["COMPILER_INLINE_TEMPLATE"]: {
-			message: `"inline-template" has been removed in Vue 3.`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
-		},
-		["COMPILER_FILTERS"]: {
-			message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
-			link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
-		}
-	};
-	function getCompatValue(key, { compatConfig }) {
-		const value = compatConfig && compatConfig[key];
-		if (key === "MODE") return value || 3;
-		else return value;
-	}
-	function isCompatEnabled(key, context) {
-		const mode = getCompatValue("MODE", context);
-		const value = getCompatValue(key, context);
-		return mode === 3 ? value === true : value !== false;
-	}
-	function checkCompatEnabled(key, context, loc, ...args) {
-		return isCompatEnabled(key, context);
-	}
-	function warnDeprecation(key, context, loc, ...args) {
-		if (getCompatValue(key, context) === "suppress-warning") return;
-		const { message, link } = deprecationData[key];
-		const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
-  Details: ${link}` : ``}`;
-		const err = new SyntaxError(msg);
-		err.code = key;
-		if (loc) err.loc = loc;
-		context.onWarn(err);
-	}
-	function defaultOnError(error) {
-		throw error;
-	}
-	function defaultOnWarn(msg) {}
-	function createCompilerError(code, loc, messages, additionalMessage) {
-		const msg = (messages || errorMessages)[code] + (additionalMessage || ``);
-		const error = new SyntaxError(String(msg));
-		error.code = code;
-		error.loc = loc;
-		return error;
-	}
-	const ErrorCodes = {
-		"ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
-		"0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
-		"CDATA_IN_HTML_CONTENT": 1,
-		"1": "CDATA_IN_HTML_CONTENT",
-		"DUPLICATE_ATTRIBUTE": 2,
-		"2": "DUPLICATE_ATTRIBUTE",
-		"END_TAG_WITH_ATTRIBUTES": 3,
-		"3": "END_TAG_WITH_ATTRIBUTES",
-		"END_TAG_WITH_TRAILING_SOLIDUS": 4,
-		"4": "END_TAG_WITH_TRAILING_SOLIDUS",
-		"EOF_BEFORE_TAG_NAME": 5,
-		"5": "EOF_BEFORE_TAG_NAME",
-		"EOF_IN_CDATA": 6,
-		"6": "EOF_IN_CDATA",
-		"EOF_IN_COMMENT": 7,
-		"7": "EOF_IN_COMMENT",
-		"EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
-		"8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
-		"EOF_IN_TAG": 9,
-		"9": "EOF_IN_TAG",
-		"INCORRECTLY_CLOSED_COMMENT": 10,
-		"10": "INCORRECTLY_CLOSED_COMMENT",
-		"INCORRECTLY_OPENED_COMMENT": 11,
-		"11": "INCORRECTLY_OPENED_COMMENT",
-		"INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
-		"12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
-		"MISSING_ATTRIBUTE_VALUE": 13,
-		"13": "MISSING_ATTRIBUTE_VALUE",
-		"MISSING_END_TAG_NAME": 14,
-		"14": "MISSING_END_TAG_NAME",
-		"MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
-		"15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
-		"NESTED_COMMENT": 16,
-		"16": "NESTED_COMMENT",
-		"UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
-		"17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
-		"UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
-		"18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
-		"UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
-		"19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
-		"UNEXPECTED_NULL_CHARACTER": 20,
-		"20": "UNEXPECTED_NULL_CHARACTER",
-		"UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
-		"21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
-		"UNEXPECTED_SOLIDUS_IN_TAG": 22,
-		"22": "UNEXPECTED_SOLIDUS_IN_TAG",
-		"X_INVALID_END_TAG": 23,
-		"23": "X_INVALID_END_TAG",
-		"X_MISSING_END_TAG": 24,
-		"24": "X_MISSING_END_TAG",
-		"X_MISSING_INTERPOLATION_END": 25,
-		"25": "X_MISSING_INTERPOLATION_END",
-		"X_MISSING_DIRECTIVE_NAME": 26,
-		"26": "X_MISSING_DIRECTIVE_NAME",
-		"X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
-		"27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
-		"X_V_IF_NO_EXPRESSION": 28,
-		"28": "X_V_IF_NO_EXPRESSION",
-		"X_V_IF_SAME_KEY": 29,
-		"29": "X_V_IF_SAME_KEY",
-		"X_V_ELSE_NO_ADJACENT_IF": 30,
-		"30": "X_V_ELSE_NO_ADJACENT_IF",
-		"X_V_FOR_NO_EXPRESSION": 31,
-		"31": "X_V_FOR_NO_EXPRESSION",
-		"X_V_FOR_MALFORMED_EXPRESSION": 32,
-		"32": "X_V_FOR_MALFORMED_EXPRESSION",
-		"X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
-		"33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
-		"X_V_BIND_NO_EXPRESSION": 34,
-		"34": "X_V_BIND_NO_EXPRESSION",
-		"X_V_ON_NO_EXPRESSION": 35,
-		"35": "X_V_ON_NO_EXPRESSION",
-		"X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
-		"36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
-		"X_V_SLOT_MIXED_SLOT_USAGE": 37,
-		"37": "X_V_SLOT_MIXED_SLOT_USAGE",
-		"X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
-		"38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
-		"X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
-		"39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
-		"X_V_SLOT_MISPLACED": 40,
-		"40": "X_V_SLOT_MISPLACED",
-		"X_V_MODEL_NO_EXPRESSION": 41,
-		"41": "X_V_MODEL_NO_EXPRESSION",
-		"X_V_MODEL_MALFORMED_EXPRESSION": 42,
-		"42": "X_V_MODEL_MALFORMED_EXPRESSION",
-		"X_V_MODEL_ON_SCOPE_VARIABLE": 43,
-		"43": "X_V_MODEL_ON_SCOPE_VARIABLE",
-		"X_V_MODEL_ON_PROPS": 44,
-		"44": "X_V_MODEL_ON_PROPS",
-		"X_INVALID_EXPRESSION": 45,
-		"45": "X_INVALID_EXPRESSION",
-		"X_KEEP_ALIVE_INVALID_CHILDREN": 46,
-		"46": "X_KEEP_ALIVE_INVALID_CHILDREN",
-		"X_PREFIX_ID_NOT_SUPPORTED": 47,
-		"47": "X_PREFIX_ID_NOT_SUPPORTED",
-		"X_MODULE_MODE_NOT_SUPPORTED": 48,
-		"48": "X_MODULE_MODE_NOT_SUPPORTED",
-		"X_CACHE_HANDLER_NOT_SUPPORTED": 49,
-		"49": "X_CACHE_HANDLER_NOT_SUPPORTED",
-		"X_SCOPE_ID_NOT_SUPPORTED": 50,
-		"50": "X_SCOPE_ID_NOT_SUPPORTED",
-		"X_VNODE_HOOKS": 51,
-		"51": "X_VNODE_HOOKS",
-		"X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 52,
-		"52": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
-		"__EXTEND_POINT__": 53,
-		"53": "__EXTEND_POINT__"
-	};
-	const errorMessages = {
-		[0]: "Illegal comment.",
-		[1]: "CDATA section is allowed only in XML context.",
-		[2]: "Duplicate attribute.",
-		[3]: "End tag cannot have attributes.",
-		[4]: "Illegal '/' in tags.",
-		[5]: "Unexpected EOF in tag.",
-		[6]: "Unexpected EOF in CDATA section.",
-		[7]: "Unexpected EOF in comment.",
-		[8]: "Unexpected EOF in script.",
-		[9]: "Unexpected EOF in tag.",
-		[10]: "Incorrectly closed comment.",
-		[11]: "Incorrectly opened comment.",
-		[12]: "Illegal tag name. Use '&lt;' to print '<'.",
-		[13]: "Attribute value was expected.",
-		[14]: "End tag name was expected.",
-		[15]: "Whitespace was expected.",
-		[16]: "Unexpected '<!--' in comment.",
-		[17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
-		[18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
-		[19]: "Attribute name cannot start with '='.",
-		[21]: "'<?' is allowed only in XML context.",
-		[20]: `Unexpected null character.`,
-		[22]: "Illegal '/' in tags.",
-		[23]: "Invalid end tag.",
-		[24]: "Element is missing end tag.",
-		[25]: "Interpolation end sign was not found.",
-		[27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
-		[26]: "Legal directive name was expected.",
-		[28]: `v-if/v-else-if is missing expression.`,
-		[29]: `v-if/else branches must use unique keys.`,
-		[30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
-		[31]: `v-for is missing expression.`,
-		[32]: `v-for has invalid expression.`,
-		[33]: `<template v-for> key should be placed on the <template> tag.`,
-		[34]: `v-bind is missing expression.`,
-		[52]: `v-bind with same-name shorthand only allows static argument.`,
-		[35]: `v-on is missing expression.`,
-		[36]: `Unexpected custom directive on <slot> outlet.`,
-		[37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
-		[38]: `Duplicate slot names found. `,
-		[39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
-		[40]: `v-slot can only be used on components or <template> tags.`,
-		[41]: `v-model is missing expression.`,
-		[42]: `v-model value must be a valid JavaScript member expression.`,
-		[43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
-		[44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
-Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
-		[45]: `Error parsing JavaScript expression: `,
-		[46]: `<KeepAlive> expects exactly one child component.`,
-		[51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
-		[47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
-		[48]: `ES module mode is not supported in this build of compiler.`,
-		[49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
-		[50]: `"scopeId" option is only supported in module mode.`,
-		[53]: ``
-	};
-	function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
-		const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root;
-		estreeWalker.walk(root, {
-			enter(node, parent) {
-				parent && parentStack.push(parent);
-				if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) return this.skip();
-				if (node.type === "Identifier") {
-					const isLocal = !!knownIds[node.name];
-					const isRefed = isReferencedIdentifier(node, parent, parentStack);
-					if (includeAll || isRefed && !isLocal) onIdentifier(node, parent, parentStack, isRefed, isLocal);
-				} else if (node.type === "ObjectProperty" && (parent == null ? void 0 : parent.type) === "ObjectPattern") node.inPattern = true;
-				else if (isFunctionType(node)) if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
-				else walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
-				else if (node.type === "BlockStatement") if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
-				else walkBlockDeclarations(node, (id) => markScopeIdentifier(node, id, knownIds));
-				else if (node.type === "SwitchStatement") if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
-				else walkSwitchStatement(node, false, (id) => markScopeIdentifier(node, id, knownIds));
-				else if (node.type === "CatchClause" && node.param) if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
-				else for (const id of extractIdentifiers(node.param)) markScopeIdentifier(node, id, knownIds);
-				else if (isForStatement(node)) if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
-				else walkForStatement(node, false, (id) => markScopeIdentifier(node, id, knownIds));
-			},
-			leave(node, parent) {
-				parent && parentStack.pop();
-				if (node !== rootExp && node.scopeIds) for (const id of node.scopeIds) {
-					knownIds[id]--;
-					if (knownIds[id] === 0) delete knownIds[id];
-				}
-			}
-		});
-	}
-	function isReferencedIdentifier(id, parent, parentStack) {
-		if (!parent) return true;
-		if (id.name === "arguments") return false;
-		if (isReferenced(id, parent, parentStack[parentStack.length - 2])) return true;
-		switch (parent.type) {
-			case "AssignmentExpression":
-			case "AssignmentPattern": return true;
-			case "ObjectProperty": return parent.key !== id && isInDestructureAssignment(parent, parentStack);
-			case "ArrayPattern": return isInDestructureAssignment(parent, parentStack);
-		}
-		return false;
-	}
-	function isInDestructureAssignment(parent, parentStack) {
-		if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
-			let i = parentStack.length;
-			while (i--) {
-				const p = parentStack[i];
-				if (p.type === "AssignmentExpression") return true;
-				else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) break;
-			}
-		}
-		return false;
-	}
-	function isInNewExpression(parentStack) {
-		let i = parentStack.length;
-		while (i--) {
-			const p = parentStack[i];
-			if (p.type === "NewExpression") return true;
-			else if (p.type !== "MemberExpression") break;
-		}
-		return false;
-	}
-	function walkFunctionParams(node, onIdent) {
-		for (const p of node.params) for (const id of extractIdentifiers(p)) onIdent(id);
-	}
-	function walkBlockDeclarations(block, onIdent) {
-		const body = block.type === "SwitchCase" ? block.consequent : block.body;
-		for (const stmt of body) if (stmt.type === "VariableDeclaration") {
-			if (stmt.declare) continue;
-			for (const decl of stmt.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
-		} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
-			if (stmt.declare || !stmt.id) continue;
-			onIdent(stmt.id);
-		} else if (isForStatement(stmt)) walkForStatement(stmt, true, onIdent);
-		else if (stmt.type === "SwitchStatement") walkSwitchStatement(stmt, true, onIdent);
-	}
-	function isForStatement(stmt) {
-		return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
-	}
-	function walkForStatement(stmt, isVar, onIdent) {
-		const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
-		if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) for (const decl of variable.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
-	}
-	function walkSwitchStatement(stmt, isVar, onIdent) {
-		for (const cs of stmt.cases) {
-			for (const stmt2 of cs.consequent) if (stmt2.type === "VariableDeclaration" && (stmt2.kind === "var" ? isVar : !isVar)) for (const decl of stmt2.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
-			walkBlockDeclarations(cs, onIdent);
-		}
-	}
-	function extractIdentifiers(param, nodes = []) {
-		switch (param.type) {
-			case "Identifier":
-				nodes.push(param);
-				break;
-			case "MemberExpression":
-				let object = param;
-				while (object.type === "MemberExpression") object = object.object;
-				nodes.push(object);
-				break;
-			case "ObjectPattern":
-				for (const prop of param.properties) if (prop.type === "RestElement") extractIdentifiers(prop.argument, nodes);
-				else extractIdentifiers(prop.value, nodes);
-				break;
-			case "ArrayPattern":
-				param.elements.forEach((element) => {
-					if (element) extractIdentifiers(element, nodes);
-				});
-				break;
-			case "RestElement":
-				extractIdentifiers(param.argument, nodes);
-				break;
-			case "AssignmentPattern":
-				extractIdentifiers(param.left, nodes);
-				break;
-		}
-		return nodes;
-	}
-	function markKnownIds(name, knownIds) {
-		if (name in knownIds) knownIds[name]++;
-		else knownIds[name] = 1;
-	}
-	function markScopeIdentifier(node, child, knownIds) {
-		const { name } = child;
-		if (node.scopeIds && node.scopeIds.has(name)) return;
-		markKnownIds(name, knownIds);
-		(node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
-	}
-	const isFunctionType = (node) => {
-		return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-	};
-	const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
-	const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
-	function isReferenced(node, parent, grandparent) {
-		switch (parent.type) {
-			case "MemberExpression":
-			case "OptionalMemberExpression":
-				if (parent.property === node) return !!parent.computed;
-				return parent.object === node;
-			case "JSXMemberExpression": return parent.object === node;
-			case "VariableDeclarator": return parent.init === node;
-			case "ArrowFunctionExpression": return parent.body === node;
-			case "PrivateName": return false;
-			case "ClassMethod":
-			case "ClassPrivateMethod":
-			case "ObjectMethod":
-				if (parent.key === node) return !!parent.computed;
-				return false;
-			case "ObjectProperty":
-				if (parent.key === node) return !!parent.computed;
-				return !grandparent || grandparent.type !== "ObjectPattern";
-			case "ClassProperty":
-				if (parent.key === node) return !!parent.computed;
-				return true;
-			case "ClassPrivateProperty": return parent.key !== node;
-			case "ClassDeclaration":
-			case "ClassExpression": return parent.superClass === node;
-			case "AssignmentExpression": return parent.right === node;
-			case "AssignmentPattern": return parent.right === node;
-			case "LabeledStatement": return false;
-			case "CatchClause": return false;
-			case "RestElement": return false;
-			case "BreakStatement":
-			case "ContinueStatement": return false;
-			case "FunctionDeclaration":
-			case "FunctionExpression": return false;
-			case "ExportNamespaceSpecifier":
-			case "ExportDefaultSpecifier": return false;
-			case "ExportSpecifier":
-				if (grandparent == null ? void 0 : grandparent.source) return false;
-				return parent.local === node;
-			case "ImportDefaultSpecifier":
-			case "ImportNamespaceSpecifier":
-			case "ImportSpecifier": return false;
-			case "ImportAttribute": return false;
-			case "JSXAttribute": return false;
-			case "ObjectPattern":
-			case "ArrayPattern": return false;
-			case "MetaProperty": return false;
-			case "ObjectTypeProperty": return parent.key !== node;
-			case "TSEnumMember": return parent.id !== node;
-			case "TSPropertySignature":
-				if (parent.key === node) return !!parent.computed;
-				return true;
-		}
-		return true;
-	}
-	const TS_NODE_TYPES = [
-		"TSAsExpression",
-		"TSTypeAssertion",
-		"TSNonNullExpression",
-		"TSInstantiationExpression",
-		"TSSatisfiesExpression"
-	];
-	function unwrapTSNode(node) {
-		if (TS_NODE_TYPES.includes(node.type)) return unwrapTSNode(node.expression);
-		else return node;
-	}
-	const isStaticExp = (p) => p.type === 4 && p.isStatic;
-	function isCoreComponent(tag) {
-		switch (tag) {
-			case "Teleport":
-			case "teleport": return TELEPORT;
-			case "Suspense":
-			case "suspense": return SUSPENSE;
-			case "KeepAlive":
-			case "keep-alive": return KEEP_ALIVE;
-			case "BaseTransition":
-			case "base-transition": return BASE_TRANSITION;
-		}
-	}
-	const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/;
-	const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
-	const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
-	const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
-	const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
-	const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
-	const isMemberExpressionBrowser = (exp) => {
-		const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
-		let state = 0;
-		let stateStack = [];
-		let currentOpenBracketCount = 0;
-		let currentOpenParensCount = 0;
-		let currentStringType = null;
-		for (let i = 0; i < path.length; i++) {
-			const char = path.charAt(i);
-			switch (state) {
-				case 0:
-					if (char === "[") {
-						stateStack.push(state);
-						state = 1;
-						currentOpenBracketCount++;
-					} else if (char === "(") {
-						stateStack.push(state);
-						state = 2;
-						currentOpenParensCount++;
-					} else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) return false;
-					break;
-				case 1:
-					if (char === `'` || char === `"` || char === "`") {
-						stateStack.push(state);
-						state = 3;
-						currentStringType = char;
-					} else if (char === `[`) currentOpenBracketCount++;
-					else if (char === `]`) {
-						if (!--currentOpenBracketCount) state = stateStack.pop();
-					}
-					break;
-				case 2:
-					if (char === `'` || char === `"` || char === "`") {
-						stateStack.push(state);
-						state = 3;
-						currentStringType = char;
-					} else if (char === `(`) currentOpenParensCount++;
-					else if (char === `)`) {
-						if (i === path.length - 1) return false;
-						if (!--currentOpenParensCount) state = stateStack.pop();
-					}
-					break;
-				case 3:
-					if (char === currentStringType) {
-						state = stateStack.pop();
-						currentStringType = null;
-					}
-					break;
-			}
-		}
-		return !currentOpenBracketCount && !currentOpenParensCount;
-	};
-	const isMemberExpressionNode = (exp, context) => {
-		try {
-			let ret = exp.ast || parser.parseExpression(getExpSource(exp), { plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] });
-			ret = unwrapTSNode(ret);
-			return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined";
-		} catch (e) {
-			return false;
-		}
-	};
-	const isMemberExpression = isMemberExpressionNode;
-	const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/;
-	const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
-	const isFnExpressionNode = (exp, context) => {
-		try {
-			let ret = exp.ast || parser.parseExpression(getExpSource(exp), { plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] });
-			if (ret.type === "Program") {
-				ret = ret.body[0];
-				if (ret.type === "ExpressionStatement") ret = ret.expression;
-			}
-			ret = unwrapTSNode(ret);
-			return ret.type === "FunctionExpression" || ret.type === "ArrowFunctionExpression";
-		} catch (e) {
-			return false;
-		}
-	};
-	const isFnExpression = isFnExpressionNode;
-	function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
-		return advancePositionWithMutation({
-			offset: pos.offset,
-			line: pos.line,
-			column: pos.column
-		}, source, numberOfCharacters);
-	}
-	function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
-		let linesCount = 0;
-		let lastNewLinePos = -1;
-		for (let i = 0; i < numberOfCharacters; i++) if (source.charCodeAt(i) === 10) {
-			linesCount++;
-			lastNewLinePos = i;
-		}
-		pos.offset += numberOfCharacters;
-		pos.line += linesCount;
-		pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
-		return pos;
-	}
-	function assert(condition, msg) {
-		if (!condition) throw new Error(msg || `unexpected compiler condition`);
-	}
-	function findDir(node, name, allowEmpty = false) {
-		for (let i = 0; i < node.props.length; i++) {
-			const p = node.props[i];
-			if (p.type === 7 && (allowEmpty || p.exp) && (shared.isString(name) ? p.name === name : name.test(p.name))) return p;
-		}
-	}
-	function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
-		for (let i = 0; i < node.props.length; i++) {
-			const p = node.props[i];
-			if (p.type === 6) {
-				if (dynamicOnly) continue;
-				if (p.name === name && (p.value || allowEmpty)) return p;
-			} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) return p;
-		}
-	}
-	function isStaticArgOf(arg, name) {
-		return !!(arg && isStaticExp(arg) && arg.content === name);
-	}
-	function hasDynamicKeyVBind(node) {
-		return node.props.some((p) => p.type === 7 && p.name === "bind" && (!p.arg || p.arg.type !== 4 || !p.arg.isStatic));
-	}
-	function isText$1(node) {
-		return node.type === 5 || node.type === 2;
-	}
-	function isVPre(p) {
-		return p.type === 7 && p.name === "pre";
-	}
-	function isVSlot(p) {
-		return p.type === 7 && p.name === "slot";
-	}
-	function isTemplateNode(node) {
-		return node.type === 1 && node.tagType === 3;
-	}
-	function isSlotOutlet(node) {
-		return node.type === 1 && node.tagType === 2;
-	}
-	const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
-	function getUnnormalizedProps(props, callPath = []) {
-		if (props && !shared.isString(props) && props.type === 14) {
-			const callee = props.callee;
-			if (!shared.isString(callee) && propsHelperSet.has(callee)) return getUnnormalizedProps(props.arguments[0], callPath.concat(props));
-		}
-		return [props, callPath];
-	}
-	function injectProp(node, prop, context) {
-		let propsWithInjection;
-		let props = node.type === 13 ? node.props : node.arguments[2];
-		let callPath = [];
-		let parentCall;
-		if (props && !shared.isString(props) && props.type === 14) {
-			const ret = getUnnormalizedProps(props);
-			props = ret[0];
-			callPath = ret[1];
-			parentCall = callPath[callPath.length - 1];
-		}
-		if (props == null || shared.isString(props)) propsWithInjection = createObjectExpression([prop]);
-		else if (props.type === 14) {
-			const first = props.arguments[0];
-			if (!shared.isString(first) && first.type === 15) {
-				if (!hasProp(prop, first)) first.properties.unshift(prop);
-			} else if (props.callee === TO_HANDLERS) propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [createObjectExpression([prop]), props]);
-			else props.arguments.unshift(createObjectExpression([prop]));
-			!propsWithInjection && (propsWithInjection = props);
-		} else if (props.type === 15) {
-			if (!hasProp(prop, props)) props.properties.unshift(prop);
-			propsWithInjection = props;
-		} else {
-			propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [createObjectExpression([prop]), props]);
-			if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) parentCall = callPath[callPath.length - 2];
-		}
-		if (node.type === 13) if (parentCall) parentCall.arguments[0] = propsWithInjection;
-		else node.props = propsWithInjection;
-		else if (parentCall) parentCall.arguments[0] = propsWithInjection;
-		else node.arguments[2] = propsWithInjection;
-	}
-	function hasProp(prop, props) {
-		let result = false;
-		if (prop.key.type === 4) {
-			const propKeyName = prop.key.content;
-			result = props.properties.some((p) => p.key.type === 4 && p.key.content === propKeyName);
-		}
-		return result;
-	}
-	function toValidAssetId(name, type) {
-		return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
-			return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
-		})}`;
-	}
-	function hasScopeRef(node, ids) {
-		if (!node || Object.keys(ids).length === 0) return false;
-		switch (node.type) {
-			case 1:
-				for (let i = 0; i < node.props.length; i++) {
-					const p = node.props[i];
-					if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) return true;
-				}
-				return node.children.some((c) => hasScopeRef(c, ids));
-			case 11:
-				if (hasScopeRef(node.source, ids)) return true;
-				return node.children.some((c) => hasScopeRef(c, ids));
-			case 9: return node.branches.some((b) => hasScopeRef(b, ids));
-			case 10:
-				if (hasScopeRef(node.condition, ids)) return true;
-				return node.children.some((c) => hasScopeRef(c, ids));
-			case 4: return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
-			case 8: return node.children.some((c) => shared.isObject(c) && hasScopeRef(c, ids));
-			case 5:
-			case 12: return hasScopeRef(node.content, ids);
-			case 2:
-			case 3:
-			case 20: return false;
-			default: return false;
-		}
-	}
-	function getMemoedVNodeCall(node) {
-		if (node.type === 14 && node.callee === WITH_MEMO) return node.arguments[1].returns;
-		else return node;
-	}
-	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
-	const defaultParserOptions = {
-		parseMode: "base",
-		ns: 0,
-		delimiters: [`{{`, `}}`],
-		getNamespace: () => 0,
-		isVoidTag: shared.NO,
-		isPreTag: shared.NO,
-		isIgnoreNewlineTag: shared.NO,
-		isCustomElement: shared.NO,
-		onError: defaultOnError,
-		onWarn: defaultOnWarn,
-		comments: false,
-		prefixIdentifiers: false
-	};
-	let currentOptions = defaultParserOptions;
-	let currentRoot = null;
-	let currentInput = "";
-	let currentOpenTag = null;
-	let currentProp = null;
-	let currentAttrValue = "";
-	let currentAttrStartIndex = -1;
-	let currentAttrEndIndex = -1;
-	let inPre = 0;
-	let inVPre = false;
-	let currentVPreBoundary = null;
-	const stack = [];
-	const tokenizer = new Tokenizer(stack, {
-		onerr: emitError,
-		ontext(start, end) {
-			onText(getSlice(start, end), start, end);
-		},
-		ontextentity(char, start, end) {
-			onText(char, start, end);
-		},
-		oninterpolation(start, end) {
-			if (inVPre) return onText(getSlice(start, end), start, end);
-			let innerStart = start + tokenizer.delimiterOpen.length;
-			let innerEnd = end - tokenizer.delimiterClose.length;
-			while (isWhitespace(currentInput.charCodeAt(innerStart))) innerStart++;
-			while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) innerEnd--;
-			let exp = getSlice(innerStart, innerEnd);
-			if (exp.includes("&")) exp = decode_js.decodeHTML(exp);
-			addNode({
-				type: 5,
-				content: createExp(exp, false, getLoc(innerStart, innerEnd)),
-				loc: getLoc(start, end)
-			});
-		},
-		onopentagname(start, end) {
-			const name = getSlice(start, end);
-			currentOpenTag = {
-				type: 1,
-				tag: name,
-				ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
-				tagType: 0,
-				props: [],
-				children: [],
-				loc: getLoc(start - 1, end),
-				codegenNode: void 0
-			};
-		},
-		onopentagend(end) {
-			endOpenTag(end);
-		},
-		onclosetag(start, end) {
-			const name = getSlice(start, end);
-			if (!currentOptions.isVoidTag(name)) {
-				let found = false;
-				for (let i = 0; i < stack.length; i++) if (stack[i].tag.toLowerCase() === name.toLowerCase()) {
-					found = true;
-					if (i > 0) emitError(24, stack[0].loc.start.offset);
-					for (let j = 0; j <= i; j++) onCloseTag(stack.shift(), end, j < i);
-					break;
-				}
-				if (!found) emitError(23, backTrack(start, 60));
-			}
-		},
-		onselfclosingtag(end) {
-			const name = currentOpenTag.tag;
-			currentOpenTag.isSelfClosing = true;
-			endOpenTag(end);
-			if (stack[0] && stack[0].tag === name) onCloseTag(stack.shift(), end);
-		},
-		onattribname(start, end) {
-			currentProp = {
-				type: 6,
-				name: getSlice(start, end),
-				nameLoc: getLoc(start, end),
-				value: void 0,
-				loc: getLoc(start)
-			};
-		},
-		ondirname(start, end) {
-			const raw = getSlice(start, end);
-			const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
-			if (!inVPre && name === "") emitError(26, start);
-			if (inVPre || name === "") currentProp = {
-				type: 6,
-				name: raw,
-				nameLoc: getLoc(start, end),
-				value: void 0,
-				loc: getLoc(start)
-			};
-			else {
-				currentProp = {
-					type: 7,
-					name,
-					rawName: raw,
-					exp: void 0,
-					arg: void 0,
-					modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
-					loc: getLoc(start)
-				};
-				if (name === "pre") {
-					inVPre = tokenizer.inVPre = true;
-					currentVPreBoundary = currentOpenTag;
-					const props = currentOpenTag.props;
-					for (let i = 0; i < props.length; i++) if (props[i].type === 7) props[i] = dirToAttr(props[i]);
-				}
-			}
-		},
-		ondirarg(start, end) {
-			if (start === end) return;
-			const arg = getSlice(start, end);
-			if (inVPre && !isVPre(currentProp)) {
-				currentProp.name += arg;
-				setLocEnd(currentProp.nameLoc, end);
-			} else {
-				const isStatic = arg[0] !== `[`;
-				currentProp.arg = createExp(isStatic ? arg : arg.slice(1, -1), isStatic, getLoc(start, end), isStatic ? 3 : 0);
-			}
-		},
-		ondirmodifier(start, end) {
-			const mod = getSlice(start, end);
-			if (inVPre && !isVPre(currentProp)) {
-				currentProp.name += "." + mod;
-				setLocEnd(currentProp.nameLoc, end);
-			} else if (currentProp.name === "slot") {
-				const arg = currentProp.arg;
-				if (arg) {
-					arg.content += "." + mod;
-					setLocEnd(arg.loc, end);
-				}
-			} else {
-				const exp = createSimpleExpression(mod, true, getLoc(start, end));
-				currentProp.modifiers.push(exp);
-			}
-		},
-		onattribdata(start, end) {
-			currentAttrValue += getSlice(start, end);
-			if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
-			currentAttrEndIndex = end;
-		},
-		onattribentity(char, start, end) {
-			currentAttrValue += char;
-			if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
-			currentAttrEndIndex = end;
-		},
-		onattribnameend(end) {
-			const start = currentProp.loc.start.offset;
-			const name = getSlice(start, end);
-			if (currentProp.type === 7) currentProp.rawName = name;
-			if (currentOpenTag.props.some((p) => (p.type === 7 ? p.rawName : p.name) === name)) emitError(2, start);
-		},
-		onattribend(quote, end) {
-			if (currentOpenTag && currentProp) {
-				setLocEnd(currentProp.loc, end);
-				if (quote !== 0) if (currentProp.type === 6) {
-					if (currentProp.name === "class") currentAttrValue = condense(currentAttrValue).trim();
-					if (quote === 1 && !currentAttrValue) emitError(13, end);
-					currentProp.value = {
-						type: 2,
-						content: currentAttrValue,
-						loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
-					};
-					if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
-				} else {
-					let expParseMode = 0;
-					if (currentProp.name === "for") expParseMode = 3;
-					else if (currentProp.name === "slot") expParseMode = 1;
-					else if (currentProp.name === "on" && currentAttrValue.includes(";")) expParseMode = 2;
-					currentProp.exp = createExp(currentAttrValue, false, getLoc(currentAttrStartIndex, currentAttrEndIndex), 0, expParseMode);
-					if (currentProp.name === "for") currentProp.forParseResult = parseForExpression(currentProp.exp);
-					let syncIndex = -1;
-					if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex((mod) => mod.content === "sync")) > -1 && checkCompatEnabled("COMPILER_V_BIND_SYNC", currentOptions, currentProp.loc, currentProp.arg.loc.source)) {
-						currentProp.name = "model";
-						currentProp.modifiers.splice(syncIndex, 1);
-					}
-				}
-				if (currentProp.type !== 7 || currentProp.name !== "pre") currentOpenTag.props.push(currentProp);
-			}
-			currentAttrValue = "";
-			currentAttrStartIndex = currentAttrEndIndex = -1;
-		},
-		oncomment(start, end) {
-			if (currentOptions.comments) addNode({
-				type: 3,
-				content: getSlice(start, end),
-				loc: getLoc(start - 4, end + 3)
-			});
-		},
-		onend() {
-			const end = currentInput.length;
-			if (tokenizer.state !== 1) switch (tokenizer.state) {
-				case 5:
-				case 8:
-					emitError(5, end);
-					break;
-				case 3:
-				case 4:
-					emitError(25, tokenizer.sectionStart);
-					break;
-				case 28:
-					if (tokenizer.currentSequence === Sequences.CdataEnd) emitError(6, end);
-					else emitError(7, end);
-					break;
-				case 6:
-				case 7:
-				case 9:
-				case 11:
-				case 12:
-				case 13:
-				case 14:
-				case 15:
-				case 16:
-				case 17:
-				case 18:
-				case 19:
-				case 20:
-				case 21:
-					emitError(9, end);
-					break;
-			}
-			for (let index = 0; index < stack.length; index++) {
-				onCloseTag(stack[index], end - 1);
-				emitError(24, stack[index].loc.start.offset);
-			}
-		},
-		oncdata(start, end) {
-			if (stack[0].ns !== 0) onText(getSlice(start, end), start, end);
-			else emitError(1, start - 9);
-		},
-		onprocessinginstruction(start) {
-			if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) emitError(21, start - 1);
-		}
-	});
-	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-	const stripParensRE = /^\(|\)$/g;
-	function parseForExpression(input) {
-		const loc = input.loc;
-		const exp = input.content;
-		const inMatch = exp.match(forAliasRE);
-		if (!inMatch) return;
-		const [, LHS, RHS] = inMatch;
-		const createAliasExpression = (content, offset, asParam = false) => {
-			const start = loc.start.offset + offset;
-			return createExp(content, false, getLoc(start, start + content.length), 0, asParam ? 1 : 0);
-		};
-		const result = {
-			source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
-			value: void 0,
-			key: void 0,
-			index: void 0,
-			finalized: false
-		};
-		let valueContent = LHS.trim().replace(stripParensRE, "").trim();
-		const trimmedOffset = LHS.indexOf(valueContent);
-		const iteratorMatch = valueContent.match(forIteratorRE);
-		if (iteratorMatch) {
-			valueContent = valueContent.replace(forIteratorRE, "").trim();
-			const keyContent = iteratorMatch[1].trim();
-			let keyOffset;
-			if (keyContent) {
-				keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
-				result.key = createAliasExpression(keyContent, keyOffset, true);
-			}
-			if (iteratorMatch[2]) {
-				const indexContent = iteratorMatch[2].trim();
-				if (indexContent) result.index = createAliasExpression(indexContent, exp.indexOf(indexContent, result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length), true);
-			}
-		}
-		if (valueContent) result.value = createAliasExpression(valueContent, trimmedOffset, true);
-		return result;
-	}
-	function getSlice(start, end) {
-		return currentInput.slice(start, end);
-	}
-	function endOpenTag(end) {
-		if (tokenizer.inSFCRoot) currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
-		addNode(currentOpenTag);
-		const { tag, ns } = currentOpenTag;
-		if (ns === 0 && currentOptions.isPreTag(tag)) inPre++;
-		if (currentOptions.isVoidTag(tag)) onCloseTag(currentOpenTag, end);
-		else {
-			stack.unshift(currentOpenTag);
-			if (ns === 1 || ns === 2) tokenizer.inXML = true;
-		}
-		currentOpenTag = null;
-	}
-	function onText(content, start, end) {
-		const parent = stack[0] || currentRoot;
-		const lastNode = parent.children[parent.children.length - 1];
-		if (lastNode && lastNode.type === 2) {
-			lastNode.content += content;
-			setLocEnd(lastNode.loc, end);
-		} else parent.children.push({
-			type: 2,
-			content,
-			loc: getLoc(start, end)
-		});
-	}
-	function onCloseTag(el, end, isImplied = false) {
-		if (isImplied) setLocEnd(el.loc, backTrack(end, 60));
-		else setLocEnd(el.loc, lookAhead(end, 62) + 1);
-		if (tokenizer.inSFCRoot) {
-			if (el.children.length) el.innerLoc.end = shared.extend({}, el.children[el.children.length - 1].loc.end);
-			else el.innerLoc.end = shared.extend({}, el.innerLoc.start);
-			el.innerLoc.source = getSlice(el.innerLoc.start.offset, el.innerLoc.end.offset);
-		}
-		const { tag, ns, children } = el;
-		if (!inVPre) {
-			if (tag === "slot") el.tagType = 2;
-			else if (isFragmentTemplate(el)) el.tagType = 3;
-			else if (isComponent(el)) el.tagType = 1;
-		}
-		if (!tokenizer.inRCDATA) el.children = condenseWhitespace(children);
-		if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
-			const first = children[0];
-			if (first && first.type === 2) first.content = first.content.replace(/^\r?\n/, "");
-		}
-		if (ns === 0 && currentOptions.isPreTag(tag)) inPre--;
-		if (currentVPreBoundary === el) {
-			inVPre = tokenizer.inVPre = false;
-			currentVPreBoundary = null;
-		}
-		if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) tokenizer.inXML = false;
-		{
-			const props = el.props;
-			if (!tokenizer.inSFCRoot && isCompatEnabled("COMPILER_NATIVE_TEMPLATE", currentOptions) && el.tag === "template" && !isFragmentTemplate(el)) {
-				const parent = stack[0] || currentRoot;
-				const index = parent.children.indexOf(el);
-				parent.children.splice(index, 1, ...el.children);
-			}
-			const inlineTemplateProp = props.find((p) => p.type === 6 && p.name === "inline-template");
-			if (inlineTemplateProp && checkCompatEnabled("COMPILER_INLINE_TEMPLATE", currentOptions, inlineTemplateProp.loc) && el.children.length) inlineTemplateProp.value = {
-				type: 2,
-				content: getSlice(el.children[0].loc.start.offset, el.children[el.children.length - 1].loc.end.offset),
-				loc: inlineTemplateProp.loc
-			};
-		}
-	}
-	function lookAhead(index, c) {
-		let i = index;
-		while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
-		return i;
-	}
-	function backTrack(index, c) {
-		let i = index;
-		while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
-		return i;
-	}
-	const specialTemplateDir = /* @__PURE__ */ new Set([
-		"if",
-		"else",
-		"else-if",
-		"for",
-		"slot"
-	]);
-	function isFragmentTemplate({ tag, props }) {
-		if (tag === "template") {
-			for (let i = 0; i < props.length; i++) if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) return true;
-		}
-		return false;
-	}
-	function isComponent({ tag, props }) {
-		if (currentOptions.isCustomElement(tag)) return false;
-		if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) return true;
-		for (let i = 0; i < props.length; i++) {
-			const p = props[i];
-			if (p.type === 6) {
-				if (p.name === "is" && p.value) {
-					if (p.value.content.startsWith("vue:")) return true;
-					else if (checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions, p.loc)) return true;
-				}
-			} else if (p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled("COMPILER_IS_ON_ELEMENT", currentOptions, p.loc)) return true;
-		}
-		return false;
-	}
-	function isUpperCase(c) {
-		return c > 64 && c < 91;
-	}
-	const windowsNewlineRE = /\r\n/g;
-	function condenseWhitespace(nodes) {
-		const shouldCondense = currentOptions.whitespace !== "preserve";
-		let removedWhitespace = false;
-		for (let i = 0; i < nodes.length; i++) {
-			const node = nodes[i];
-			if (node.type === 2) if (!inPre) {
-				if (isAllWhitespace(node.content)) {
-					const prev = nodes[i - 1] && nodes[i - 1].type;
-					const next = nodes[i + 1] && nodes[i + 1].type;
-					if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
-						removedWhitespace = true;
-						nodes[i] = null;
-					} else node.content = " ";
-				} else if (shouldCondense) node.content = condense(node.content);
-			} else node.content = node.content.replace(windowsNewlineRE, "\n");
-		}
-		return removedWhitespace ? nodes.filter(Boolean) : nodes;
-	}
-	function isAllWhitespace(str) {
-		for (let i = 0; i < str.length; i++) if (!isWhitespace(str.charCodeAt(i))) return false;
-		return true;
-	}
-	function hasNewlineChar(str) {
-		for (let i = 0; i < str.length; i++) {
-			const c = str.charCodeAt(i);
-			if (c === 10 || c === 13) return true;
-		}
-		return false;
-	}
-	function condense(str) {
-		let ret = "";
-		let prevCharIsWhitespace = false;
-		for (let i = 0; i < str.length; i++) if (isWhitespace(str.charCodeAt(i))) {
-			if (!prevCharIsWhitespace) {
-				ret += " ";
-				prevCharIsWhitespace = true;
-			}
-		} else {
-			ret += str[i];
-			prevCharIsWhitespace = false;
-		}
-		return ret;
-	}
-	function addNode(node) {
-		(stack[0] || currentRoot).children.push(node);
-	}
-	function getLoc(start, end) {
-		return {
-			start: tokenizer.getPos(start),
-			end: end == null ? end : tokenizer.getPos(end),
-			source: end == null ? end : getSlice(start, end)
-		};
-	}
-	function cloneLoc(loc) {
-		return getLoc(loc.start.offset, loc.end.offset);
-	}
-	function setLocEnd(loc, end) {
-		loc.end = tokenizer.getPos(end);
-		loc.source = getSlice(loc.start.offset, end);
-	}
-	function dirToAttr(dir) {
-		const attr = {
-			type: 6,
-			name: dir.rawName,
-			nameLoc: getLoc(dir.loc.start.offset, dir.loc.start.offset + dir.rawName.length),
-			value: void 0,
-			loc: dir.loc
-		};
-		if (dir.exp) {
-			const loc = dir.exp.loc;
-			if (loc.end.offset < dir.loc.end.offset) {
-				loc.start.offset--;
-				loc.start.column--;
-				loc.end.offset++;
-				loc.end.column++;
-			}
-			attr.value = {
-				type: 2,
-				content: dir.exp.content,
-				loc
-			};
-		}
-		return attr;
-	}
-	function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0) {
-		const exp = createSimpleExpression(content, isStatic, loc, constType);
-		if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 && content.trim()) {
-			if (isSimpleIdentifier(content)) {
-				exp.ast = null;
-				return exp;
-			}
-			try {
-				const plugins = currentOptions.expressionPlugins;
-				const options = { plugins: plugins ? [...plugins, "typescript"] : ["typescript"] };
-				if (parseMode === 2) exp.ast = parser.parse(` ${content} `, options).program;
-				else if (parseMode === 1) exp.ast = parser.parseExpression(`(${content})=>{}`, options);
-				else exp.ast = parser.parseExpression(`(${content})`, options);
-			} catch (e) {
-				exp.ast = false;
-				emitError(45, loc.start.offset, e.message);
-			}
-		}
-		return exp;
-	}
-	function emitError(code, index, message) {
-		currentOptions.onError(createCompilerError(code, getLoc(index, index), void 0, message));
-	}
-	function reset() {
-		tokenizer.reset();
-		currentOpenTag = null;
-		currentProp = null;
-		currentAttrValue = "";
-		currentAttrStartIndex = -1;
-		currentAttrEndIndex = -1;
-		stack.length = 0;
-	}
-	function baseParse(input, options) {
-		reset();
-		currentInput = input;
-		currentOptions = shared.extend({}, defaultParserOptions);
-		if (options) {
-			let key;
-			for (key in options) if (options[key] != null) currentOptions[key] = options[key];
-		}
-		tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
-		tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
-		const delimiters = options && options.delimiters;
-		if (delimiters) {
-			tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
-			tokenizer.delimiterClose = toCharCodes(delimiters[1]);
-		}
-		const root = currentRoot = createRoot([], input);
-		tokenizer.parse(currentInput);
-		root.loc = getLoc(0, input.length);
-		root.children = condenseWhitespace(root.children);
-		currentRoot = null;
-		return root;
-	}
-	function cacheStatic(root, context) {
-		walk(root, void 0, context, !!getSingleElementRoot(root));
-	}
-	function getSingleElementRoot(root) {
-		const children = root.children.filter((x) => x.type !== 3);
-		return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;
-	}
-	function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
-		const { children } = node;
-		const toCache = [];
-		for (let i = 0; i < children.length; i++) {
-			const child = children[i];
-			if (child.type === 1 && child.tagType === 0) {
-				const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
-				if (constantType > 0) {
-					if (constantType >= 2) {
-						child.codegenNode.patchFlag = -1;
-						toCache.push(child);
-						continue;
-					}
-				} else {
-					const codegenNode = child.codegenNode;
-					if (codegenNode.type === 13) {
-						const flag = codegenNode.patchFlag;
-						if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
-							const props = getNodeProps(child);
-							if (props) codegenNode.props = context.hoist(props);
-						}
-						if (codegenNode.dynamicProps) codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
-					}
-				}
-			} else if (child.type === 12) {
-				if ((doNotHoistNode ? 0 : getConstantType(child, context)) >= 2) {
-					if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) child.codegenNode.arguments.push("-1");
-					toCache.push(child);
-					continue;
-				}
-			}
-			if (child.type === 1) {
-				const isComponent$1 = child.tagType === 1;
-				if (isComponent$1) context.scopes.vSlot++;
-				walk(child, node, context, false, inFor);
-				if (isComponent$1) context.scopes.vSlot--;
-			} else if (child.type === 11) walk(child, node, context, child.children.length === 1, true);
-			else if (child.type === 9) for (let i2 = 0; i2 < child.branches.length; i2++) walk(child.branches[i2], node, context, child.branches[i2].children.length === 1, inFor);
-		}
-		let cachedAsArray = false;
-		if (toCache.length === children.length && node.type === 1) {
-			if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && shared.isArray(node.codegenNode.children)) {
-				node.codegenNode.children = getCacheExpression(createArrayExpression(node.codegenNode.children));
-				cachedAsArray = true;
-			} else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !shared.isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
-				const slot = getSlotNode(node.codegenNode, "default");
-				if (slot) {
-					slot.returns = getCacheExpression(createArrayExpression(slot.returns));
-					cachedAsArray = true;
-				}
-			} else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
-				const slotName = findDir(node, "slot", true);
-				const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
-				if (slot) {
-					slot.returns = getCacheExpression(createArrayExpression(slot.returns));
-					cachedAsArray = true;
-				}
-			}
-		}
-		if (!cachedAsArray) for (const child of toCache) child.codegenNode = context.cache(child.codegenNode);
-		function getCacheExpression(value) {
-			const exp = context.cache(value);
-			exp.needArraySpread = true;
-			return exp;
-		}
-		function getSlotNode(node2, name) {
-			if (node2.children && !shared.isArray(node2.children) && node2.children.type === 15) {
-				const slot = node2.children.properties.find((p) => p.key === name || p.key.content === name);
-				return slot && slot.value;
-			}
-		}
-		if (toCache.length && context.transformHoist) context.transformHoist(children, context, node);
-	}
-	function getConstantType(node, context) {
-		const { constantCache } = context;
-		switch (node.type) {
-			case 1:
-				if (node.tagType !== 0) return 0;
-				const cached = constantCache.get(node);
-				if (cached !== void 0) return cached;
-				const codegenNode = node.codegenNode;
-				if (codegenNode.type !== 13) return 0;
-				if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") return 0;
-				if (codegenNode.patchFlag === void 0) {
-					let returnType2 = 3;
-					const generatedPropsType = getGeneratedPropsConstantType(node, context);
-					if (generatedPropsType === 0) {
-						constantCache.set(node, 0);
-						return 0;
-					}
-					if (generatedPropsType < returnType2) returnType2 = generatedPropsType;
-					for (let i = 0; i < node.children.length; i++) {
-						const childType = getConstantType(node.children[i], context);
-						if (childType === 0) {
-							constantCache.set(node, 0);
-							return 0;
-						}
-						if (childType < returnType2) returnType2 = childType;
-					}
-					if (returnType2 > 1) for (let i = 0; i < node.props.length; i++) {
-						const p = node.props[i];
-						if (p.type === 7 && p.name === "bind" && p.exp) {
-							const expType = getConstantType(p.exp, context);
-							if (expType === 0) {
-								constantCache.set(node, 0);
-								return 0;
-							}
-							if (expType < returnType2) returnType2 = expType;
-						}
-					}
-					if (codegenNode.isBlock) {
-						for (let i = 0; i < node.props.length; i++) if (node.props[i].type === 7) {
-							constantCache.set(node, 0);
-							return 0;
-						}
-						context.removeHelper(OPEN_BLOCK);
-						context.removeHelper(getVNodeBlockHelper(context.inSSR, codegenNode.isComponent));
-						codegenNode.isBlock = false;
-						context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
-					}
-					constantCache.set(node, returnType2);
-					return returnType2;
-				} else {
-					constantCache.set(node, 0);
-					return 0;
-				}
-			case 2:
-			case 3: return 3;
-			case 9:
-			case 11:
-			case 10: return 0;
-			case 5:
-			case 12: return getConstantType(node.content, context);
-			case 4: return node.constType;
-			case 8:
-				let returnType = 3;
-				for (let i = 0; i < node.children.length; i++) {
-					const child = node.children[i];
-					if (shared.isString(child) || shared.isSymbol(child)) continue;
-					const childType = getConstantType(child, context);
-					if (childType === 0) return 0;
-					else if (childType < returnType) returnType = childType;
-				}
-				return returnType;
-			case 20: return 2;
-			default: return 0;
-		}
-	}
-	const allowHoistedHelperSet = /* @__PURE__ */ new Set([
-		NORMALIZE_CLASS,
-		NORMALIZE_STYLE,
-		NORMALIZE_PROPS,
-		GUARD_REACTIVE_PROPS
-	]);
-	function getConstantTypeOfHelperCall(value, context) {
-		if (value.type === 14 && !shared.isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
-			const arg = value.arguments[0];
-			if (arg.type === 4) return getConstantType(arg, context);
-			else if (arg.type === 14) return getConstantTypeOfHelperCall(arg, context);
-		}
-		return 0;
-	}
-	function getGeneratedPropsConstantType(node, context) {
-		let returnType = 3;
-		const props = getNodeProps(node);
-		if (props && props.type === 15) {
-			const { properties } = props;
-			for (let i = 0; i < properties.length; i++) {
-				const { key, value } = properties[i];
-				const keyType = getConstantType(key, context);
-				if (keyType === 0) return keyType;
-				if (keyType < returnType) returnType = keyType;
-				let valueType;
-				if (value.type === 4) valueType = getConstantType(value, context);
-				else if (value.type === 14) valueType = getConstantTypeOfHelperCall(value, context);
-				else valueType = 0;
-				if (valueType === 0) return valueType;
-				if (valueType < returnType) returnType = valueType;
-			}
-		}
-		return returnType;
-	}
-	function getNodeProps(node) {
-		const codegenNode = node.codegenNode;
-		if (codegenNode.type === 13) return codegenNode.props;
-	}
-	function createTransformContext(root, { filename = "", prefixIdentifiers = false, hoistStatic = false, hmr = false, cacheHandlers = false, nodeTransforms = [], directiveTransforms = {}, transformHoist = null, isBuiltInComponent = shared.NOOP, isCustomElement = shared.NOOP, expressionPlugins = [], scopeId = null, slotted = true, ssr = false, inSSR = false, ssrCssVars = ``, bindingMetadata = shared.EMPTY_OBJ, inline = false, isTS = false, onError = defaultOnError, onWarn = defaultOnWarn, compatConfig }) {
-		const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
-		const context = {
-			filename,
-			selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])),
-			prefixIdentifiers,
-			hoistStatic,
-			hmr,
-			cacheHandlers,
-			nodeTransforms,
-			directiveTransforms,
-			transformHoist,
-			isBuiltInComponent,
-			isCustomElement,
-			expressionPlugins,
-			scopeId,
-			slotted,
-			ssr,
-			inSSR,
-			ssrCssVars,
-			bindingMetadata,
-			inline,
-			isTS,
-			onError,
-			onWarn,
-			compatConfig,
-			root,
-			helpers: /* @__PURE__ */ new Map(),
-			components: /* @__PURE__ */ new Set(),
-			directives: /* @__PURE__ */ new Set(),
-			hoists: [],
-			imports: [],
-			cached: [],
-			constantCache: /* @__PURE__ */ new WeakMap(),
-			temps: 0,
-			identifiers: /* @__PURE__ */ Object.create(null),
-			scopes: {
-				vFor: 0,
-				vSlot: 0,
-				vPre: 0,
-				vOnce: 0
-			},
-			parent: null,
-			grandParent: null,
-			currentNode: root,
-			childIndex: 0,
-			inVOnce: false,
-			helper(name) {
-				const count = context.helpers.get(name) || 0;
-				context.helpers.set(name, count + 1);
-				return name;
-			},
-			removeHelper(name) {
-				const count = context.helpers.get(name);
-				if (count) {
-					const currentCount = count - 1;
-					if (!currentCount) context.helpers.delete(name);
-					else context.helpers.set(name, currentCount);
-				}
-			},
-			helperString(name) {
-				return `_${helperNameMap[context.helper(name)]}`;
-			},
-			replaceNode(node) {
-				context.parent.children[context.childIndex] = context.currentNode = node;
-			},
-			removeNode(node) {
-				const list = context.parent.children;
-				const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
-				if (!node || node === context.currentNode) {
-					context.currentNode = null;
-					context.onNodeRemoved();
-				} else if (context.childIndex > removalIndex) {
-					context.childIndex--;
-					context.onNodeRemoved();
-				}
-				context.parent.children.splice(removalIndex, 1);
-			},
-			onNodeRemoved: shared.NOOP,
-			addIdentifiers(exp) {
-				if (shared.isString(exp)) addId(exp);
-				else if (exp.identifiers) exp.identifiers.forEach(addId);
-				else if (exp.type === 4) addId(exp.content);
-			},
-			removeIdentifiers(exp) {
-				if (shared.isString(exp)) removeId(exp);
-				else if (exp.identifiers) exp.identifiers.forEach(removeId);
-				else if (exp.type === 4) removeId(exp.content);
-			},
-			hoist(exp) {
-				if (shared.isString(exp)) exp = createSimpleExpression(exp);
-				context.hoists.push(exp);
-				const identifier = createSimpleExpression(`_hoisted_${context.hoists.length}`, false, exp.loc, 2);
-				identifier.hoisted = exp;
-				return identifier;
-			},
-			cache(exp, isVNode = false, inVOnce = false) {
-				const cacheExp = createCacheExpression(context.cached.length, exp, isVNode, inVOnce);
-				context.cached.push(cacheExp);
-				return cacheExp;
-			}
-		};
-		context.filters = /* @__PURE__ */ new Set();
-		function addId(id) {
-			const { identifiers } = context;
-			if (identifiers[id] === void 0) identifiers[id] = 0;
-			identifiers[id]++;
-		}
-		function removeId(id) {
-			context.identifiers[id]--;
-		}
-		return context;
-	}
-	function transform(root, options) {
-		const context = createTransformContext(root, options);
-		traverseNode(root, context);
-		if (options.hoistStatic) cacheStatic(root, context);
-		if (!options.ssr) createRootCodegen(root, context);
-		root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
-		root.components = [...context.components];
-		root.directives = [...context.directives];
-		root.imports = context.imports;
-		root.hoists = context.hoists;
-		root.temps = context.temps;
-		root.cached = context.cached;
-		root.transformed = true;
-		root.filters = [...context.filters];
-	}
-	function createRootCodegen(root, context) {
-		const { helper } = context;
-		const { children } = root;
-		if (children.length === 1) {
-			const singleElementRootChild = getSingleElementRoot(root);
-			if (singleElementRootChild && singleElementRootChild.codegenNode) {
-				const codegenNode = singleElementRootChild.codegenNode;
-				if (codegenNode.type === 13) convertToBlock(codegenNode, context);
-				root.codegenNode = codegenNode;
-			} else root.codegenNode = children[0];
-		} else if (children.length > 1) root.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, root.children, 64, void 0, void 0, true, void 0, false);
-	}
-	function traverseChildren(parent, context) {
-		let i = 0;
-		const nodeRemoved = () => {
-			i--;
-		};
-		for (; i < parent.children.length; i++) {
-			const child = parent.children[i];
-			if (shared.isString(child)) continue;
-			context.grandParent = context.parent;
-			context.parent = parent;
-			context.childIndex = i;
-			context.onNodeRemoved = nodeRemoved;
-			traverseNode(child, context);
-		}
-	}
-	function traverseNode(node, context) {
-		context.currentNode = node;
-		const { nodeTransforms } = context;
-		const exitFns = [];
-		for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
-			const onExit = nodeTransforms[i2](node, context);
-			if (onExit) if (shared.isArray(onExit)) exitFns.push(...onExit);
-			else exitFns.push(onExit);
-			if (!context.currentNode) return;
-			else node = context.currentNode;
-		}
-		switch (node.type) {
-			case 3:
-				if (!context.ssr) context.helper(CREATE_COMMENT);
-				break;
-			case 5:
-				if (!context.ssr) context.helper(TO_DISPLAY_STRING);
-				break;
-			case 9:
-				for (let i2 = 0; i2 < node.branches.length; i2++) traverseNode(node.branches[i2], context);
-				break;
-			case 10:
-			case 11:
-			case 1:
-			case 0:
-				traverseChildren(node, context);
-				break;
-		}
-		context.currentNode = node;
-		let i = exitFns.length;
-		while (i--) exitFns[i]();
-	}
-	function createStructuralDirectiveTransform(name, fn) {
-		const matches = shared.isString(name) ? (n) => n === name : (n) => name.test(n);
-		return (node, context) => {
-			if (node.type === 1) {
-				const { props } = node;
-				if (node.tagType === 3 && props.some(isVSlot)) return;
-				const exitFns = [];
-				for (let i = 0; i < props.length; i++) {
-					const prop = props[i];
-					if (prop.type === 7 && matches(prop.name)) {
-						props.splice(i, 1);
-						i--;
-						const onExit = fn(node, prop, context);
-						if (onExit) exitFns.push(onExit);
-					}
-				}
-				return exitFns;
-			}
-		};
-	}
-	const PURE_ANNOTATION = `/*@__PURE__*/`;
-	const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
-	function createCodegenContext(ast, { mode = "function", prefixIdentifiers = mode === "module", sourceMap = false, filename = `template.vue.html`, scopeId = null, optimizeImports = false, runtimeGlobalName = `Vue`, runtimeModuleName = `vue`, ssrRuntimeModuleName = "vue/server-renderer", ssr = false, isTS = false, inSSR = false }) {
-		const context = {
-			mode,
-			prefixIdentifiers,
-			sourceMap,
-			filename,
-			scopeId,
-			optimizeImports,
-			runtimeGlobalName,
-			runtimeModuleName,
-			ssrRuntimeModuleName,
-			ssr,
-			isTS,
-			inSSR,
-			source: ast.source,
-			code: ``,
-			column: 1,
-			line: 1,
-			offset: 0,
-			indentLevel: 0,
-			pure: false,
-			map: void 0,
-			helper(key) {
-				return `_${helperNameMap[key]}`;
-			},
-			push(code, newlineIndex = -2, node) {
-				context.code += code;
-				if (context.map) {
-					if (node) {
-						let name;
-						if (node.type === 4 && !node.isStatic) {
-							const content = node.content.replace(/^_ctx\./, "");
-							if (content !== node.content && isSimpleIdentifier(content)) name = content;
-						}
-						if (node.loc.source) addMapping(node.loc.start, name);
-					}
-					if (newlineIndex === -3) advancePositionWithMutation(context, code);
-					else {
-						context.offset += code.length;
-						if (newlineIndex === -2) context.column += code.length;
-						else {
-							if (newlineIndex === -1) newlineIndex = code.length - 1;
-							context.line++;
-							context.column = code.length - newlineIndex;
-						}
-					}
-					if (node && node.loc !== locStub && node.loc.source) addMapping(node.loc.end);
-				}
-			},
-			indent() {
-				newline(++context.indentLevel);
-			},
-			deindent(withoutNewLine = false) {
-				if (withoutNewLine) --context.indentLevel;
-				else newline(--context.indentLevel);
-			},
-			newline() {
-				newline(context.indentLevel);
-			}
-		};
-		function newline(n) {
-			context.push("\n" + `  `.repeat(n), 0);
-		}
-		function addMapping(loc, name = null) {
-			const { _names, _mappings } = context.map;
-			if (name !== null && !_names.has(name)) _names.add(name);
-			_mappings.add({
-				originalLine: loc.line,
-				originalColumn: loc.column - 1,
-				generatedLine: context.line,
-				generatedColumn: context.column - 1,
-				source: filename,
-				name
-			});
-		}
-		if (sourceMap) {
-			context.map = new sourceMapJs.SourceMapGenerator();
-			context.map.setSourceContent(filename, context.source);
-			context.map._sources.add(filename);
-		}
-		return context;
-	}
-	function generate(ast, options = {}) {
-		const context = createCodegenContext(ast, options);
-		if (options.onContextCreated) options.onContextCreated(context);
-		const { mode, push, prefixIdentifiers, indent, deindent, newline, scopeId, ssr } = context;
-		const helpers = Array.from(ast.helpers);
-		const hasHelpers = helpers.length > 0;
-		const useWithBlock = !prefixIdentifiers && mode !== "module";
-		const genScopeId = scopeId != null && mode === "module";
-		const isSetupInlined = !!options.inline;
-		const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;
-		if (mode === "module") genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);
-		else genFunctionPreamble(ast, preambleContext);
-		const functionName = ssr ? `ssrRender` : `render`;
-		const args = ssr ? [
-			"_ctx",
-			"_push",
-			"_parent",
-			"_attrs"
-		] : ["_ctx", "_cache"];
-		if (options.bindingMetadata && !options.inline) args.push("$props", "$setup", "$data", "$options");
-		const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", ");
-		if (isSetupInlined) push(`(${signature}) => {`);
-		else push(`function ${functionName}(${signature}) {`);
-		indent();
-		if (useWithBlock) {
-			push(`with (_ctx) {`);
-			indent();
-			if (hasHelpers) {
-				push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
-`, -1);
-				newline();
-			}
-		}
-		if (ast.components.length) {
-			genAssets(ast.components, "component", context);
-			if (ast.directives.length || ast.temps > 0) newline();
-		}
-		if (ast.directives.length) {
-			genAssets(ast.directives, "directive", context);
-			if (ast.temps > 0) newline();
-		}
-		if (ast.filters && ast.filters.length) {
-			newline();
-			genAssets(ast.filters, "filter", context);
-			newline();
-		}
-		if (ast.temps > 0) {
-			push(`let `);
-			for (let i = 0; i < ast.temps; i++) push(`${i > 0 ? `, ` : ``}_temp${i}`);
-		}
-		if (ast.components.length || ast.directives.length || ast.temps) {
-			push(`
-`, 0);
-			newline();
-		}
-		if (!ssr) push(`return `);
-		if (ast.codegenNode) genNode(ast.codegenNode, context);
-		else push(`null`);
-		if (useWithBlock) {
-			deindent();
-			push(`}`);
-		}
-		deindent();
-		push(`}`);
-		return {
-			ast,
-			code: context.code,
-			preamble: isSetupInlined ? preambleContext.code : ``,
-			map: context.map ? context.map.toJSON() : void 0
-		};
-	}
-	function genFunctionPreamble(ast, context) {
-		const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context;
-		const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;
-		const helpers = Array.from(ast.helpers);
-		if (helpers.length > 0) if (prefixIdentifiers) push(`const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding}
-`, -1);
-		else {
-			push(`const _Vue = ${VueBinding}
-`, -1);
-			if (ast.hoists.length) push(`const { ${[
-				CREATE_VNODE,
-				CREATE_ELEMENT_VNODE,
-				CREATE_COMMENT,
-				CREATE_TEXT,
-				CREATE_STATIC
-			].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ")} } = _Vue
-`, -1);
-		}
-		if (ast.ssrHelpers && ast.ssrHelpers.length) push(`const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}")
-`, -1);
-		genHoists(ast.hoists, context);
-		newline();
-		push(`return `);
-	}
-	function genModulePreamble(ast, context, genScopeId, inline) {
-		const { push, newline, optimizeImports, runtimeModuleName, ssrRuntimeModuleName } = context;
-		if (ast.helpers.size) {
-			const helpers = Array.from(ast.helpers);
-			if (optimizeImports) {
-				push(`import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
-`, -1);
-				push(`
-// Binding optimization for webpack code-split
-const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")}
-`, -1);
-			} else push(`import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
-`, -1);
-		}
-		if (ast.ssrHelpers && ast.ssrHelpers.length) push(`import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}"
-`, -1);
-		if (ast.imports.length) {
-			genImports(ast.imports, context);
-			newline();
-		}
-		genHoists(ast.hoists, context);
-		newline();
-		if (!inline) push(`export `);
-	}
-	function genAssets(assets, type, { helper, push, newline, isTS }) {
-		const resolver = helper(type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE);
-		for (let i = 0; i < assets.length; i++) {
-			let id = assets[i];
-			const maybeSelfReference = id.endsWith("__self");
-			if (maybeSelfReference) id = id.slice(0, -6);
-			push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`);
-			if (i < assets.length - 1) newline();
-		}
-	}
-	function genHoists(hoists, context) {
-		if (!hoists.length) return;
-		context.pure = true;
-		const { push, newline } = context;
-		newline();
-		for (let i = 0; i < hoists.length; i++) {
-			const exp = hoists[i];
-			if (exp) {
-				push(`const _hoisted_${i + 1} = `);
-				genNode(exp, context);
-				newline();
-			}
-		}
-		context.pure = false;
-	}
-	function genImports(importsOptions, context) {
-		if (!importsOptions.length) return;
-		importsOptions.forEach((imports) => {
-			context.push(`import `);
-			genNode(imports.exp, context);
-			context.push(` from '${imports.path}'`);
-			context.newline();
-		});
-	}
-	function isText(n) {
-		return shared.isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
-	}
-	function genNodeListAsArray(nodes, context) {
-		const multilines = nodes.length > 3 || nodes.some((n) => shared.isArray(n) || !isText(n));
-		context.push(`[`);
-		multilines && context.indent();
-		genNodeList(nodes, context, multilines);
-		multilines && context.deindent();
-		context.push(`]`);
-	}
-	function genNodeList(nodes, context, multilines = false, comma = true) {
-		const { push, newline } = context;
-		for (let i = 0; i < nodes.length; i++) {
-			const node = nodes[i];
-			if (shared.isString(node)) push(node, -3);
-			else if (shared.isArray(node)) genNodeListAsArray(node, context);
-			else genNode(node, context);
-			if (i < nodes.length - 1) if (multilines) {
-				comma && push(",");
-				newline();
-			} else comma && push(", ");
-		}
-	}
-	function genNode(node, context) {
-		if (shared.isString(node)) {
-			context.push(node, -3);
-			return;
-		}
-		if (shared.isSymbol(node)) {
-			context.push(context.helper(node));
-			return;
-		}
-		switch (node.type) {
-			case 1:
-			case 9:
-			case 11:
-				genNode(node.codegenNode, context);
-				break;
-			case 2:
-				genText(node, context);
-				break;
-			case 4:
-				genExpression(node, context);
-				break;
-			case 5:
-				genInterpolation(node, context);
-				break;
-			case 12:
-				genNode(node.codegenNode, context);
-				break;
-			case 8:
-				genCompoundExpression(node, context);
-				break;
-			case 3:
-				genComment(node, context);
-				break;
-			case 13:
-				genVNodeCall(node, context);
-				break;
-			case 14:
-				genCallExpression(node, context);
-				break;
-			case 15:
-				genObjectExpression(node, context);
-				break;
-			case 17:
-				genArrayExpression(node, context);
-				break;
-			case 18:
-				genFunctionExpression(node, context);
-				break;
-			case 19:
-				genConditionalExpression(node, context);
-				break;
-			case 20:
-				genCacheExpression(node, context);
-				break;
-			case 21:
-				genNodeList(node.body, context, true, false);
-				break;
-			case 22:
-				genTemplateLiteral(node, context);
-				break;
-			case 23:
-				genIfStatement(node, context);
-				break;
-			case 24:
-				genAssignmentExpression(node, context);
-				break;
-			case 25:
-				genSequenceExpression(node, context);
-				break;
-			case 26:
-				genReturnStatement(node, context);
-				break;
-		}
-	}
-	function genText(node, context) {
-		context.push(JSON.stringify(node.content), -3, node);
-	}
-	function genExpression(node, context) {
-		const { content, isStatic } = node;
-		context.push(isStatic ? JSON.stringify(content) : content, -3, node);
-	}
-	function genInterpolation(node, context) {
-		const { push, helper, pure } = context;
-		if (pure) push(PURE_ANNOTATION);
-		push(`${helper(TO_DISPLAY_STRING)}(`);
-		genNode(node.content, context);
-		push(`)`);
-	}
-	function genCompoundExpression(node, context) {
-		for (let i = 0; i < node.children.length; i++) {
-			const child = node.children[i];
-			if (shared.isString(child)) context.push(child, -3);
-			else genNode(child, context);
-		}
-	}
-	function genExpressionAsPropertyKey(node, context) {
-		const { push } = context;
-		if (node.type === 8) {
-			push(`[`);
-			genCompoundExpression(node, context);
-			push(`]`);
-		} else if (node.isStatic) push(isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content), -2, node);
-		else push(`[${node.content}]`, -3, node);
-	}
-	function genComment(node, context) {
-		const { push, helper, pure } = context;
-		if (pure) push(PURE_ANNOTATION);
-		push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, -3, node);
-	}
-	function genVNodeCall(node, context) {
-		const { push, helper, pure } = context;
-		const { tag, props, children, patchFlag, dynamicProps, directives, isBlock, disableTracking, isComponent: isComponent$1 } = node;
-		let patchFlagString;
-		if (patchFlag) patchFlagString = String(patchFlag);
-		if (directives) push(helper(WITH_DIRECTIVES) + `(`);
-		if (isBlock) push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
-		if (pure) push(PURE_ANNOTATION);
-		push(helper(isBlock ? getVNodeBlockHelper(context.inSSR, isComponent$1) : getVNodeHelper(context.inSSR, isComponent$1)) + `(`, -2, node);
-		genNodeList(genNullableArgs([
-			tag,
-			props,
-			children,
-			patchFlagString,
-			dynamicProps
-		]), context);
-		push(`)`);
-		if (isBlock) push(`)`);
-		if (directives) {
-			push(`, `);
-			genNode(directives, context);
-			push(`)`);
-		}
-	}
-	function genNullableArgs(args) {
-		let i = args.length;
-		while (i--) if (args[i] != null) break;
-		return args.slice(0, i + 1).map((arg) => arg || `null`);
-	}
-	function genCallExpression(node, context) {
-		const { push, helper, pure } = context;
-		const callee = shared.isString(node.callee) ? node.callee : helper(node.callee);
-		if (pure) push(PURE_ANNOTATION);
-		push(callee + `(`, -2, node);
-		genNodeList(node.arguments, context);
-		push(`)`);
-	}
-	function genObjectExpression(node, context) {
-		const { push, indent, deindent, newline } = context;
-		const { properties } = node;
-		if (!properties.length) {
-			push(`{}`, -2, node);
-			return;
-		}
-		const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
-		push(multilines ? `{` : `{ `);
-		multilines && indent();
-		for (let i = 0; i < properties.length; i++) {
-			const { key, value } = properties[i];
-			genExpressionAsPropertyKey(key, context);
-			push(`: `);
-			genNode(value, context);
-			if (i < properties.length - 1) {
-				push(`,`);
-				newline();
-			}
-		}
-		multilines && deindent();
-		push(multilines ? `}` : ` }`);
-	}
-	function genArrayExpression(node, context) {
-		genNodeListAsArray(node.elements, context);
-	}
-	function genFunctionExpression(node, context) {
-		const { push, indent, deindent } = context;
-		const { params, returns, body, newline, isSlot } = node;
-		if (isSlot) push(`_${helperNameMap[WITH_CTX]}(`);
-		push(`(`, -2, node);
-		if (shared.isArray(params)) genNodeList(params, context);
-		else if (params) genNode(params, context);
-		push(`) => `);
-		if (newline || body) {
-			push(`{`);
-			indent();
-		}
-		if (returns) {
-			if (newline) push(`return `);
-			if (shared.isArray(returns)) genNodeListAsArray(returns, context);
-			else genNode(returns, context);
-		} else if (body) genNode(body, context);
-		if (newline || body) {
-			deindent();
-			push(`}`);
-		}
-		if (isSlot) {
-			if (node.isNonScopedSlot) push(`, undefined, true`);
-			push(`)`);
-		}
-	}
-	function genConditionalExpression(node, context) {
-		const { test, consequent, alternate, newline: needNewline } = node;
-		const { push, indent, deindent, newline } = context;
-		if (test.type === 4) {
-			const needsParens = !isSimpleIdentifier(test.content);
-			needsParens && push(`(`);
-			genExpression(test, context);
-			needsParens && push(`)`);
-		} else {
-			push(`(`);
-			genNode(test, context);
-			push(`)`);
-		}
-		needNewline && indent();
-		context.indentLevel++;
-		needNewline || push(` `);
-		push(`? `);
-		genNode(consequent, context);
-		context.indentLevel--;
-		needNewline && newline();
-		needNewline || push(` `);
-		push(`: `);
-		const isNested = alternate.type === 19;
-		if (!isNested) context.indentLevel++;
-		genNode(alternate, context);
-		if (!isNested) context.indentLevel--;
-		needNewline && deindent(true);
-	}
-	function genCacheExpression(node, context) {
-		const { push, helper, indent, deindent, newline } = context;
-		const { needPauseTracking, needArraySpread } = node;
-		if (needArraySpread) push(`[...(`);
-		push(`_cache[${node.index}] || (`);
-		if (needPauseTracking) {
-			indent();
-			push(`${helper(SET_BLOCK_TRACKING)}(-1`);
-			if (node.inVOnce) push(`, true`);
-			push(`),`);
-			newline();
-			push(`(`);
-		}
-		push(`_cache[${node.index}] = `);
-		genNode(node.value, context);
-		if (needPauseTracking) {
-			push(`).cacheIndex = ${node.index},`);
-			newline();
-			push(`${helper(SET_BLOCK_TRACKING)}(1),`);
-			newline();
-			push(`_cache[${node.index}]`);
-			deindent();
-		}
-		push(`)`);
-		if (needArraySpread) push(`)]`);
-	}
-	function genTemplateLiteral(node, context) {
-		const { push, indent, deindent } = context;
-		push("`");
-		const l = node.elements.length;
-		const multilines = l > 3;
-		for (let i = 0; i < l; i++) {
-			const e = node.elements[i];
-			if (shared.isString(e)) push(e.replace(/(`|\$|\\)/g, "\\$1"), -3);
-			else {
-				push("${");
-				if (multilines) indent();
-				genNode(e, context);
-				if (multilines) deindent();
-				push("}");
-			}
-		}
-		push("`");
-	}
-	function genIfStatement(node, context) {
-		const { push, indent, deindent } = context;
-		const { test, consequent, alternate } = node;
-		push(`if (`);
-		genNode(test, context);
-		push(`) {`);
-		indent();
-		genNode(consequent, context);
-		deindent();
-		push(`}`);
-		if (alternate) {
-			push(` else `);
-			if (alternate.type === 23) genIfStatement(alternate, context);
-			else {
-				push(`{`);
-				indent();
-				genNode(alternate, context);
-				deindent();
-				push(`}`);
-			}
-		}
-	}
-	function genAssignmentExpression(node, context) {
-		genNode(node.left, context);
-		context.push(` = `);
-		genNode(node.right, context);
-	}
-	function genSequenceExpression(node, context) {
-		context.push(`(`);
-		genNodeList(node.expressions, context);
-		context.push(`)`);
-	}
-	function genReturnStatement({ returns }, context) {
-		context.push(`return `);
-		if (shared.isArray(returns)) genNodeListAsArray(returns, context);
-		else genNode(returns, context);
-	}
-	const isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap("true,false,null,this");
-	const transformExpression = (node, context) => {
-		if (node.type === 5) node.content = processExpression(node.content, context);
-		else if (node.type === 1) {
-			const memo = findDir(node, "memo");
-			for (let i = 0; i < node.props.length; i++) {
-				const dir = node.props[i];
-				if (dir.type === 7 && dir.name !== "for") {
-					const exp = dir.exp;
-					const arg = dir.arg;
-					if (exp && exp.type === 4 && !(dir.name === "on" && arg) && !(memo && arg && arg.type === 4 && arg.content === "key")) dir.exp = processExpression(exp, context, dir.name === "slot");
-					if (arg && arg.type === 4 && !arg.isStatic) dir.arg = processExpression(arg, context);
-				}
-			}
-		}
-	};
-	function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
-		if (!context.prefixIdentifiers || !node.content.trim()) return node;
-		const { inline, bindingMetadata } = context;
-		const rewriteIdentifier = (raw, parent, id) => {
-			const type = shared.hasOwn(bindingMetadata, raw) && bindingMetadata[raw];
-			if (inline) {
-				const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
-				const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
-				const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
-				const isNewExpression = parent && isInNewExpression(parentStack);
-				const wrapWithUnref = (raw2) => {
-					const wrapped = `${context.helperString(UNREF)}(${raw2})`;
-					return isNewExpression ? `(${wrapped})` : wrapped;
-				};
-				if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) return raw;
-				else if (type === "setup-ref") return `${raw}.value`;
-				else if (type === "setup-maybe-ref") return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : wrapWithUnref(raw);
-				else if (type === "setup-let") if (isAssignmentLVal) {
-					const { right: rVal, operator } = parent;
-					const rExpString = stringifyExpression(processExpression(createSimpleExpression(rawExp.slice(rVal.start - 1, rVal.end - 1), false), context, false, false, knownIds));
-					return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
-` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
-				} else if (isUpdateArg) {
-					id.start = parent.start;
-					id.end = parent.end;
-					const { prefix: isPrefix, operator } = parent;
-					const prefix = isPrefix ? operator : ``;
-					const postfix = isPrefix ? `` : operator;
-					return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
-` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
-				} else if (isDestructureAssignment) return raw;
-				else return wrapWithUnref(raw);
-				else if (type === "props") return shared.genPropsAccessExp(raw);
-				else if (type === "props-aliased") return shared.genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
-			} else if (type && type.startsWith("setup") || type === "literal-const") return `$setup.${raw}`;
-			else if (type === "props-aliased") return `$props['${bindingMetadata.__propsAliases[raw]}']`;
-			else if (type) return `$${type}.${raw}`;
-			return `_ctx.${raw}`;
-		};
-		const rawExp = node.content;
-		let ast = node.ast;
-		if (ast === false) return node;
-		if (ast === null || !ast && isSimpleIdentifier(rawExp)) {
-			const isScopeVarReference = context.identifiers[rawExp];
-			const isAllowedGlobal = shared.isGloballyAllowed(rawExp);
-			const isLiteral = isLiteralWhitelisted(rawExp);
-			if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {
-				if (isConst(bindingMetadata[rawExp])) node.constType = 1;
-				node.content = rewriteIdentifier(rawExp);
-			} else if (!isScopeVarReference) if (isLiteral) node.constType = 3;
-			else node.constType = 2;
-			return node;
-		}
-		if (!ast) {
-			const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
-			try {
-				ast = parser.parseExpression(source, {
-					sourceType: "module",
-					plugins: context.expressionPlugins
-				});
-			} catch (e) {
-				context.onError(createCompilerError(45, node.loc, void 0, e.message));
-				return node;
-			}
-		}
-		const ids = [];
-		const parentStack = [];
-		const knownIds = Object.create(context.identifiers);
-		walkIdentifiers(ast, (node2, parent, _, isReferenced$1, isLocal) => {
-			if (isStaticPropertyKey(node2, parent)) return;
-			if (node2.name.startsWith("_filter_")) return;
-			const needPrefix = isReferenced$1 && canPrefix(node2);
-			if (needPrefix && !isLocal) {
-				if (isStaticProperty(parent) && parent.shorthand) node2.prefix = `${node2.name}: `;
-				node2.name = rewriteIdentifier(node2.name, parent, node2);
-				ids.push(node2);
-			} else {
-				if (!(needPrefix && isLocal) && (!parent || parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "MemberExpression")) node2.isConstant = true;
-				ids.push(node2);
-			}
-		}, true, parentStack, knownIds);
-		const children = [];
-		ids.sort((a, b) => a.start - b.start);
-		ids.forEach((id, i) => {
-			const start = id.start - 1;
-			const end = id.end - 1;
-			const last = ids[i - 1];
-			const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
-			if (leadingText.length || id.prefix) children.push(leadingText + (id.prefix || ``));
-			const source = rawExp.slice(start, end);
-			children.push(createSimpleExpression(id.name, false, {
-				start: advancePositionWithClone(node.loc.start, source, start),
-				end: advancePositionWithClone(node.loc.start, source, end),
-				source
-			}, id.isConstant ? 3 : 0));
-			if (i === ids.length - 1 && end < rawExp.length) children.push(rawExp.slice(end));
-		});
-		let ret;
-		if (children.length) {
-			ret = createCompoundExpression(children, node.loc);
-			ret.ast = ast;
-		} else {
-			ret = node;
-			ret.constType = 3;
-		}
-		ret.identifiers = Object.keys(knownIds);
-		return ret;
-	}
-	function canPrefix(id) {
-		if (shared.isGloballyAllowed(id.name)) return false;
-		if (id.name === "require") return false;
-		return true;
-	}
-	function stringifyExpression(exp) {
-		if (shared.isString(exp)) return exp;
-		else if (exp.type === 4) return exp.content;
-		else return exp.children.map(stringifyExpression).join("");
-	}
-	function isConst(type) {
-		return type === "setup-const" || type === "literal-const";
-	}
-	const transformIf = createStructuralDirectiveTransform(/^(?:if|else|else-if)$/, (node, dir, context) => {
-		return processIf(node, dir, context, (ifNode, branch, isRoot) => {
-			const siblings = context.parent.children;
-			let i = siblings.indexOf(ifNode);
-			let key = 0;
-			while (i-- >= 0) {
-				const sibling = siblings[i];
-				if (sibling && sibling.type === 9) key += sibling.branches.length;
-			}
-			return () => {
-				if (isRoot) ifNode.codegenNode = createCodegenNodeForBranch(branch, key, context);
-				else {
-					const parentCondition = getParentCondition(ifNode.codegenNode);
-					parentCondition.alternate = createCodegenNodeForBranch(branch, key + ifNode.branches.length - 1, context);
-				}
-			};
-		});
-	});
-	function processIf(node, dir, context, processCodegen) {
-		if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
-			const loc = dir.exp ? dir.exp.loc : node.loc;
-			context.onError(createCompilerError(28, dir.loc));
-			dir.exp = createSimpleExpression(`true`, false, loc);
-		}
-		if (context.prefixIdentifiers && dir.exp) dir.exp = processExpression(dir.exp, context);
-		if (dir.name === "if") {
-			const branch = createIfBranch(node, dir);
-			const ifNode = {
-				type: 9,
-				loc: cloneLoc(node.loc),
-				branches: [branch]
-			};
-			context.replaceNode(ifNode);
-			if (processCodegen) return processCodegen(ifNode, branch, true);
-		} else {
-			const siblings = context.parent.children;
-			let i = siblings.indexOf(node);
-			while (i-- >= -1) {
-				const sibling = siblings[i];
-				if (sibling && sibling.type === 3) {
-					context.removeNode(sibling);
-					continue;
-				}
-				if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
-					context.removeNode(sibling);
-					continue;
-				}
-				if (sibling && sibling.type === 9) {
-					if ((dir.name === "else-if" || dir.name === "else") && sibling.branches[sibling.branches.length - 1].condition === void 0) context.onError(createCompilerError(30, node.loc));
-					context.removeNode();
-					const branch = createIfBranch(node, dir);
-					{
-						const key = branch.userKey;
-						if (key) sibling.branches.forEach(({ userKey }) => {
-							if (isSameKey(userKey, key)) context.onError(createCompilerError(29, branch.userKey.loc));
-						});
-					}
-					sibling.branches.push(branch);
-					const onExit = processCodegen && processCodegen(sibling, branch, false);
-					traverseNode(branch, context);
-					if (onExit) onExit();
-					context.currentNode = null;
-				} else context.onError(createCompilerError(30, node.loc));
-				break;
-			}
-		}
-	}
-	function createIfBranch(node, dir) {
-		const isTemplateIf = node.tagType === 3;
-		return {
-			type: 10,
-			loc: node.loc,
-			condition: dir.name === "else" ? void 0 : dir.exp,
-			children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
-			userKey: findProp(node, `key`),
-			isTemplateIf
-		};
-	}
-	function createCodegenNodeForBranch(branch, keyIndex, context) {
-		if (branch.condition) return createConditionalExpression(branch.condition, createChildrenCodegenNode(branch, keyIndex, context), createCallExpression(context.helper(CREATE_COMMENT), ["\"\"", "true"]));
-		else return createChildrenCodegenNode(branch, keyIndex, context);
-	}
-	function createChildrenCodegenNode(branch, keyIndex, context) {
-		const { helper } = context;
-		const keyProperty = createObjectProperty(`key`, createSimpleExpression(`${keyIndex}`, false, locStub, 2));
-		const { children } = branch;
-		const firstChild = children[0];
-		if (children.length !== 1 || firstChild.type !== 1) if (children.length === 1 && firstChild.type === 11) {
-			const vnodeCall = firstChild.codegenNode;
-			injectProp(vnodeCall, keyProperty, context);
-			return vnodeCall;
-		} else return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, 64, void 0, void 0, true, false, false, branch.loc);
-		else {
-			const ret = firstChild.codegenNode;
-			const vnodeCall = getMemoedVNodeCall(ret);
-			if (vnodeCall.type === 13) convertToBlock(vnodeCall, context);
-			injectProp(vnodeCall, keyProperty, context);
-			return ret;
-		}
-	}
-	function isSameKey(a, b) {
-		if (!a || a.type !== b.type) return false;
-		if (a.type === 6) {
-			if (a.value.content !== b.value.content) return false;
-		} else {
-			const exp = a.exp;
-			const branchExp = b.exp;
-			if (exp.type !== branchExp.type) return false;
-			if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) return false;
-		}
-		return true;
-	}
-	function getParentCondition(node) {
-		while (true) if (node.type === 19) if (node.alternate.type === 19) node = node.alternate;
-		else return node;
-		else if (node.type === 20) node = node.value;
-	}
-	const transformFor = createStructuralDirectiveTransform("for", (node, dir, context) => {
-		const { helper, removeHelper } = context;
-		return processFor(node, dir, context, (forNode) => {
-			const renderExp = createCallExpression(helper(RENDER_LIST), [forNode.source]);
-			const isTemplate = isTemplateNode(node);
-			const memo = findDir(node, "memo");
-			const keyProp = findProp(node, `key`, false, true);
-			const isDirKey = keyProp && keyProp.type === 7;
-			let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
-			if (memo && keyExp && isDirKey) keyProp.exp = keyExp = processExpression(keyExp, context);
-			const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
-			if (isTemplate) {
-				if (memo) memo.exp = processExpression(memo.exp, context);
-				if (keyProperty && keyProp.type !== 6) keyProperty.value = processExpression(keyProperty.value, context);
-			}
-			const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
-			const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
-			forNode.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, renderExp, fragmentFlag, void 0, void 0, true, !isStableFragment, false, node.loc);
-			return () => {
-				let childBlock;
-				const { children } = forNode;
-				if (isTemplate) node.children.some((c) => {
-					if (c.type === 1) {
-						const key = findProp(c, "key");
-						if (key) {
-							context.onError(createCompilerError(33, key.loc));
-							return true;
-						}
-					}
-				});
-				const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
-				const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
-				if (slotOutlet) {
-					childBlock = slotOutlet.codegenNode;
-					if (isTemplate && keyProperty) injectProp(childBlock, keyProperty, context);
-				} else if (needFragmentWrapper) childBlock = createVNodeCall(context, helper(FRAGMENT), keyProperty ? createObjectExpression([keyProperty]) : void 0, node.children, 64, void 0, void 0, true, void 0, false);
-				else {
-					childBlock = children[0].codegenNode;
-					if (isTemplate && keyProperty) injectProp(childBlock, keyProperty, context);
-					if (childBlock.isBlock !== !isStableFragment) if (childBlock.isBlock) {
-						removeHelper(OPEN_BLOCK);
-						removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
-					} else removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent));
-					childBlock.isBlock = !isStableFragment;
-					if (childBlock.isBlock) {
-						helper(OPEN_BLOCK);
-						helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
-					} else helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
-				}
-				if (memo) {
-					const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [createSimpleExpression(`_cached`)]));
-					loop.body = createBlockStatement([
-						createCompoundExpression([
-							`const _memo = (`,
-							memo.exp,
-							`)`
-						]),
-						createCompoundExpression([
-							`if (_cached`,
-							...keyExp ? [` && _cached.key === `, keyExp] : [],
-							` && ${context.helperString(IS_MEMO_SAME)}(_cached, _memo)) return _cached`
-						]),
-						createCompoundExpression([`const _item = `, childBlock]),
-						createSimpleExpression(`_item.memo = _memo`),
-						createSimpleExpression(`return _item`)
-					]);
-					renderExp.arguments.push(loop, createSimpleExpression(`_cache`), createSimpleExpression(String(context.cached.length)));
-					context.cached.push(null);
-				} else renderExp.arguments.push(createFunctionExpression(createForLoopParams(forNode.parseResult), childBlock, true));
-			};
-		});
-	});
-	function processFor(node, dir, context, processCodegen) {
-		if (!dir.exp) {
-			context.onError(createCompilerError(31, dir.loc));
-			return;
-		}
-		const parseResult = dir.forParseResult;
-		if (!parseResult) {
-			context.onError(createCompilerError(32, dir.loc));
-			return;
-		}
-		finalizeForParseResult(parseResult, context);
-		const { addIdentifiers, removeIdentifiers, scopes } = context;
-		const { source, value, key, index } = parseResult;
-		const forNode = {
-			type: 11,
-			loc: dir.loc,
-			source,
-			valueAlias: value,
-			keyAlias: key,
-			objectIndexAlias: index,
-			parseResult,
-			children: isTemplateNode(node) ? node.children : [node]
-		};
-		context.replaceNode(forNode);
-		scopes.vFor++;
-		if (context.prefixIdentifiers) {
-			value && addIdentifiers(value);
-			key && addIdentifiers(key);
-			index && addIdentifiers(index);
-		}
-		const onExit = processCodegen && processCodegen(forNode);
-		return () => {
-			scopes.vFor--;
-			if (context.prefixIdentifiers) {
-				value && removeIdentifiers(value);
-				key && removeIdentifiers(key);
-				index && removeIdentifiers(index);
-			}
-			if (onExit) onExit();
-		};
-	}
-	function finalizeForParseResult(result, context) {
-		if (result.finalized) return;
-		if (context.prefixIdentifiers) {
-			result.source = processExpression(result.source, context);
-			if (result.key) result.key = processExpression(result.key, context, true);
-			if (result.index) result.index = processExpression(result.index, context, true);
-			if (result.value) result.value = processExpression(result.value, context, true);
-		}
-		result.finalized = true;
-	}
-	function createForLoopParams({ value, key, index }, memoArgs = []) {
-		return createParamsList([
-			value,
-			key,
-			index,
-			...memoArgs
-		]);
-	}
-	function createParamsList(args) {
-		let i = args.length;
-		while (i--) if (args[i]) break;
-		return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
-	}
-	const defaultFallback = createSimpleExpression(`undefined`, false);
-	const trackSlotScopes = (node, context) => {
-		if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
-			const vSlot = findDir(node, "slot");
-			if (vSlot) {
-				const slotProps = vSlot.exp;
-				if (context.prefixIdentifiers) slotProps && context.addIdentifiers(slotProps);
-				context.scopes.vSlot++;
-				return () => {
-					if (context.prefixIdentifiers) slotProps && context.removeIdentifiers(slotProps);
-					context.scopes.vSlot--;
-				};
-			}
-		}
-	};
-	const trackVForSlotScopes = (node, context) => {
-		let vFor;
-		if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
-			const result = vFor.forParseResult;
-			if (result) {
-				finalizeForParseResult(result, context);
-				const { value, key, index } = result;
-				const { addIdentifiers, removeIdentifiers } = context;
-				value && addIdentifiers(value);
-				key && addIdentifiers(key);
-				index && addIdentifiers(index);
-				return () => {
-					value && removeIdentifiers(value);
-					key && removeIdentifiers(key);
-					index && removeIdentifiers(index);
-				};
-			}
-		}
-	};
-	const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(props, children, false, true, children.length ? children[0].loc : loc);
-	function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
-		context.helper(WITH_CTX);
-		const { children, loc } = node;
-		const slotsProperties = [];
-		const dynamicSlots = [];
-		let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
-		if (!context.ssr && context.prefixIdentifiers) hasDynamicSlots = node.props.some((prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers))) || children.some((child) => hasScopeRef(child, context.identifiers));
-		const onComponentSlot = findDir(node, "slot", true);
-		if (onComponentSlot) {
-			const { arg, exp } = onComponentSlot;
-			if (arg && !isStaticExp(arg)) hasDynamicSlots = true;
-			slotsProperties.push(createObjectProperty(arg || createSimpleExpression("default", true), buildSlotFn(exp, void 0, children, loc)));
-		}
-		let hasTemplateSlots = false;
-		let hasNamedDefaultSlot = false;
-		const implicitDefaultChildren = [];
-		const seenSlotNames = /* @__PURE__ */ new Set();
-		let conditionalBranchIndex = 0;
-		for (let i = 0; i < children.length; i++) {
-			const slotElement = children[i];
-			let slotDir;
-			if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
-				if (slotElement.type !== 3) implicitDefaultChildren.push(slotElement);
-				continue;
-			}
-			if (onComponentSlot) {
-				context.onError(createCompilerError(37, slotDir.loc));
-				break;
-			}
-			hasTemplateSlots = true;
-			const { children: slotChildren, loc: slotLoc } = slotElement;
-			const { arg: slotName = createSimpleExpression(`default`, true), exp: slotProps, loc: dirLoc } = slotDir;
-			let staticSlotName;
-			if (isStaticExp(slotName)) staticSlotName = slotName ? slotName.content : `default`;
-			else hasDynamicSlots = true;
-			const vFor = findDir(slotElement, "for");
-			const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
-			let vIf;
-			let vElse;
-			if (vIf = findDir(slotElement, "if")) {
-				hasDynamicSlots = true;
-				dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback));
-			} else if (vElse = findDir(slotElement, /^else(?:-if)?$/, true)) {
-				let j = i;
-				let prev;
-				while (j--) {
-					prev = children[j];
-					if (prev.type !== 3 && isNonWhitespaceContent(prev)) break;
-				}
-				if (prev && isTemplateNode(prev) && findDir(prev, /^(?:else-)?if$/)) {
-					let conditional = dynamicSlots[dynamicSlots.length - 1];
-					while (conditional.alternate.type === 19) conditional = conditional.alternate;
-					conditional.alternate = vElse.exp ? createConditionalExpression(vElse.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
-				} else context.onError(createCompilerError(30, vElse.loc));
-			} else if (vFor) {
-				hasDynamicSlots = true;
-				const parseResult = vFor.forParseResult;
-				if (parseResult) {
-					finalizeForParseResult(parseResult, context);
-					dynamicSlots.push(createCallExpression(context.helper(RENDER_LIST), [parseResult.source, createFunctionExpression(createForLoopParams(parseResult), buildDynamicSlot(slotName, slotFunction), true)]));
-				} else context.onError(createCompilerError(32, vFor.loc));
-			} else {
-				if (staticSlotName) {
-					if (seenSlotNames.has(staticSlotName)) {
-						context.onError(createCompilerError(38, dirLoc));
-						continue;
-					}
-					seenSlotNames.add(staticSlotName);
-					if (staticSlotName === "default") hasNamedDefaultSlot = true;
-				}
-				slotsProperties.push(createObjectProperty(slotName, slotFunction));
-			}
-		}
-		if (!onComponentSlot) {
-			const buildDefaultSlotProperty = (props, children2) => {
-				const fn = buildSlotFn(props, void 0, children2, loc);
-				if (context.compatConfig) fn.isNonScopedSlot = true;
-				return createObjectProperty(`default`, fn);
-			};
-			if (!hasTemplateSlots) slotsProperties.push(buildDefaultSlotProperty(void 0, children));
-			else if (implicitDefaultChildren.length && implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) if (hasNamedDefaultSlot) context.onError(createCompilerError(39, implicitDefaultChildren[0].loc));
-			else slotsProperties.push(buildDefaultSlotProperty(void 0, implicitDefaultChildren));
-		}
-		const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
-		let slots = createObjectExpression(slotsProperties.concat(createObjectProperty(`_`, createSimpleExpression(slotFlag + ``, false))), loc);
-		if (dynamicSlots.length) slots = createCallExpression(context.helper(CREATE_SLOTS), [slots, createArrayExpression(dynamicSlots)]);
-		return {
-			slots,
-			hasDynamicSlots
-		};
-	}
-	function buildDynamicSlot(name, fn, index) {
-		const props = [createObjectProperty(`name`, name), createObjectProperty(`fn`, fn)];
-		if (index != null) props.push(createObjectProperty(`key`, createSimpleExpression(String(index), true)));
-		return createObjectExpression(props);
-	}
-	function hasForwardedSlots(children) {
-		for (let i = 0; i < children.length; i++) {
-			const child = children[i];
-			switch (child.type) {
-				case 1:
-					if (child.tagType === 2 || hasForwardedSlots(child.children)) return true;
-					break;
-				case 9:
-					if (hasForwardedSlots(child.branches)) return true;
-					break;
-				case 10:
-				case 11:
-					if (hasForwardedSlots(child.children)) return true;
-					break;
-			}
-		}
-		return false;
-	}
-	function isNonWhitespaceContent(node) {
-		if (node.type !== 2 && node.type !== 12) return true;
-		return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
-	}
-	const directiveImportMap = /* @__PURE__ */ new WeakMap();
-	const transformElement = (node, context) => {
-		return function postTransformElement() {
-			node = context.currentNode;
-			if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) return;
-			const { tag, props } = node;
-			const isComponent$1 = node.tagType === 1;
-			let vnodeTag = isComponent$1 ? resolveComponentType(node, context) : `"${tag}"`;
-			const isDynamicComponent = shared.isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
-			let vnodeProps;
-			let vnodeChildren;
-			let patchFlag = 0;
-			let vnodeDynamicProps;
-			let dynamicPropNames;
-			let vnodeDirectives;
-			let shouldUseBlock = isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent$1 && (tag === "svg" || tag === "foreignObject" || tag === "math");
-			if (props.length > 0) {
-				const propsBuildResult = buildProps(node, context, void 0, isComponent$1, isDynamicComponent);
-				vnodeProps = propsBuildResult.props;
-				patchFlag = propsBuildResult.patchFlag;
-				dynamicPropNames = propsBuildResult.dynamicPropNames;
-				const directives = propsBuildResult.directives;
-				vnodeDirectives = directives && directives.length ? createArrayExpression(directives.map((dir) => buildDirectiveArgs(dir, context))) : void 0;
-				if (propsBuildResult.shouldUseBlock) shouldUseBlock = true;
-			}
-			if (node.children.length > 0) {
-				if (vnodeTag === KEEP_ALIVE) {
-					shouldUseBlock = true;
-					patchFlag |= 1024;
-				}
-				if (isComponent$1 && vnodeTag !== TELEPORT && vnodeTag !== KEEP_ALIVE) {
-					const { slots, hasDynamicSlots } = buildSlots(node, context);
-					vnodeChildren = slots;
-					if (hasDynamicSlots) patchFlag |= 1024;
-				} else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
-					const child = node.children[0];
-					const type = child.type;
-					const hasDynamicTextChild = type === 5 || type === 8;
-					if (hasDynamicTextChild && getConstantType(child, context) === 0) patchFlag |= 1;
-					if (hasDynamicTextChild || type === 2) vnodeChildren = child;
-					else vnodeChildren = node.children;
-				} else vnodeChildren = node.children;
-			}
-			if (dynamicPropNames && dynamicPropNames.length) vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
-			node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, patchFlag === 0 ? void 0 : patchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false, isComponent$1, node.loc);
-		};
-	};
-	function resolveComponentType(node, context, ssr = false) {
-		let { tag } = node;
-		const isExplicitDynamic = isComponentTag(tag);
-		const isProp = findProp(node, "is", false, true);
-		if (isProp) {
-			if (isExplicitDynamic || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context)) {
-				let exp;
-				if (isProp.type === 6) exp = isProp.value && createSimpleExpression(isProp.value.content, true);
-				else {
-					exp = isProp.exp;
-					if (!exp) {
-						exp = createSimpleExpression(`is`, false, isProp.arg.loc);
-						exp = isProp.exp = processExpression(exp, context);
-					}
-				}
-				if (exp) return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [exp]);
-			} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) tag = isProp.value.content.slice(4);
-		}
-		const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
-		if (builtIn) {
-			if (!ssr) context.helper(builtIn);
-			return builtIn;
-		}
-		{
-			const fromSetup = resolveSetupReference(tag, context);
-			if (fromSetup) return fromSetup;
-			const dotIndex = tag.indexOf(".");
-			if (dotIndex > 0) {
-				const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
-				if (ns) return ns + tag.slice(dotIndex);
-			}
-		}
-		if (context.selfName && shared.capitalize(shared.camelize(tag)) === context.selfName) {
-			context.helper(RESOLVE_COMPONENT);
-			context.components.add(tag + `__self`);
-			return toValidAssetId(tag, `component`);
-		}
-		context.helper(RESOLVE_COMPONENT);
-		context.components.add(tag);
-		return toValidAssetId(tag, `component`);
-	}
-	function resolveSetupReference(name, context) {
-		const bindings = context.bindingMetadata;
-		if (!bindings || bindings.__isScriptSetup === false) return;
-		const camelName = shared.camelize(name);
-		const PascalName = shared.capitalize(camelName);
-		const checkType = (type) => {
-			if (bindings[name] === type) return name;
-			if (bindings[camelName] === type) return camelName;
-			if (bindings[PascalName] === type) return PascalName;
-		};
-		const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const");
-		if (fromConst) return context.inline ? fromConst : `$setup[${JSON.stringify(fromConst)}]`;
-		const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref");
-		if (fromMaybeRef) return context.inline ? `${context.helperString(UNREF)}(${fromMaybeRef})` : `$setup[${JSON.stringify(fromMaybeRef)}]`;
-		const fromProps = checkType("props");
-		if (fromProps) return `${context.helperString(UNREF)}(${context.inline ? "__props" : "$props"}[${JSON.stringify(fromProps)}])`;
-	}
-	function buildProps(node, context, props = node.props, isComponent$1, isDynamicComponent, ssr = false) {
-		const { tag, loc: elementLoc, children } = node;
-		let properties = [];
-		const mergeArgs = [];
-		const runtimeDirectives = [];
-		const hasChildren = children.length > 0;
-		let shouldUseBlock = false;
-		let patchFlag = 0;
-		let hasRef = false;
-		let hasClassBinding = false;
-		let hasStyleBinding = false;
-		let hasHydrationEventBinding = false;
-		let hasDynamicKeys = false;
-		let hasVnodeHook = false;
-		const dynamicPropNames = [];
-		const pushMergeArg = (arg) => {
-			if (properties.length) {
-				mergeArgs.push(createObjectExpression(dedupeProperties(properties), elementLoc));
-				properties = [];
-			}
-			if (arg) mergeArgs.push(arg);
-		};
-		const pushRefVForMarker = () => {
-			if (context.scopes.vFor > 0) properties.push(createObjectProperty(createSimpleExpression("ref_for", true), createSimpleExpression("true")));
-		};
-		const analyzePatchFlag = ({ key, value }) => {
-			if (isStaticExp(key)) {
-				const name = key.content;
-				const isEventHandler = shared.isOn(name);
-				if (isEventHandler && (!isComponent$1 || isDynamicComponent) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue" && !shared.isReservedProp(name)) hasHydrationEventBinding = true;
-				if (isEventHandler && shared.isReservedProp(name)) hasVnodeHook = true;
-				if (isEventHandler && value.type === 14) value = value.arguments[0];
-				if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) return;
-				if (name === "ref") hasRef = true;
-				else if (name === "class") hasClassBinding = true;
-				else if (name === "style") hasStyleBinding = true;
-				else if (name !== "key" && !dynamicPropNames.includes(name)) dynamicPropNames.push(name);
-				if (isComponent$1 && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) dynamicPropNames.push(name);
-			} else hasDynamicKeys = true;
-		};
-		for (let i = 0; i < props.length; i++) {
-			const prop = props[i];
-			if (prop.type === 6) {
-				const { loc, name, nameLoc, value } = prop;
-				let isStatic = true;
-				if (name === "ref") {
-					hasRef = true;
-					pushRefVForMarker();
-					if (value && context.inline) {
-						const binding = context.bindingMetadata[value.content];
-						if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") {
-							isStatic = false;
-							properties.push(createObjectProperty(createSimpleExpression("ref_key", true), createSimpleExpression(value.content, true, value.loc)));
-						}
-					}
-				}
-				if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
-				properties.push(createObjectProperty(createSimpleExpression(name, true, nameLoc), createSimpleExpression(value ? value.content : "", isStatic, value ? value.loc : loc)));
-			} else {
-				const { name, arg, exp, loc, modifiers } = prop;
-				const isVBind = name === "bind";
-				const isVOn = name === "on";
-				if (name === "slot") {
-					if (!isComponent$1) context.onError(createCompilerError(40, loc));
-					continue;
-				}
-				if (name === "once" || name === "memo") continue;
-				if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled("COMPILER_IS_ON_ELEMENT", context))) continue;
-				if (isVOn && ssr) continue;
-				if (isVBind && isStaticArgOf(arg, "key") || isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")) shouldUseBlock = true;
-				if (isVBind && isStaticArgOf(arg, "ref")) pushRefVForMarker();
-				if (!arg && (isVBind || isVOn)) {
-					hasDynamicKeys = true;
-					if (exp) if (isVBind) {
-						pushMergeArg();
-						if (isCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context)) {
-							mergeArgs.unshift(exp);
-							continue;
-						}
-						pushRefVForMarker();
-						pushMergeArg();
-						mergeArgs.push(exp);
-					} else pushMergeArg({
-						type: 14,
-						loc,
-						callee: context.helper(TO_HANDLERS),
-						arguments: isComponent$1 ? [exp] : [exp, `true`]
-					});
-					else context.onError(createCompilerError(isVBind ? 34 : 35, loc));
-					continue;
-				}
-				if (isVBind && modifiers.some((mod) => mod.content === "prop")) patchFlag |= 32;
-				const directiveTransform = context.directiveTransforms[name];
-				if (directiveTransform) {
-					const { props: props2, needRuntime } = directiveTransform(prop, node, context);
-					!ssr && props2.forEach(analyzePatchFlag);
-					if (isVOn && arg && !isStaticExp(arg)) pushMergeArg(createObjectExpression(props2, elementLoc));
-					else properties.push(...props2);
-					if (needRuntime) {
-						runtimeDirectives.push(prop);
-						if (shared.isSymbol(needRuntime)) directiveImportMap.set(prop, needRuntime);
-					}
-				} else if (!shared.isBuiltInDirective(name)) {
-					runtimeDirectives.push(prop);
-					if (hasChildren) shouldUseBlock = true;
-				}
-			}
-		}
-		let propsExpression = void 0;
-		if (mergeArgs.length) {
-			pushMergeArg();
-			if (mergeArgs.length > 1) propsExpression = createCallExpression(context.helper(MERGE_PROPS), mergeArgs, elementLoc);
-			else propsExpression = mergeArgs[0];
-		} else if (properties.length) propsExpression = createObjectExpression(dedupeProperties(properties), elementLoc);
-		if (hasDynamicKeys) patchFlag |= 16;
-		else {
-			if (hasClassBinding && !isComponent$1) patchFlag |= 2;
-			if (hasStyleBinding && !isComponent$1) patchFlag |= 4;
-			if (dynamicPropNames.length) patchFlag |= 8;
-			if (hasHydrationEventBinding) patchFlag |= 32;
-		}
-		if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) patchFlag |= 512;
-		if (!context.inSSR && propsExpression) switch (propsExpression.type) {
-			case 15:
-				let classKeyIndex = -1;
-				let styleKeyIndex = -1;
-				let hasDynamicKey = false;
-				for (let i = 0; i < propsExpression.properties.length; i++) {
-					const key = propsExpression.properties[i].key;
-					if (isStaticExp(key)) {
-						if (key.content === "class") classKeyIndex = i;
-						else if (key.content === "style") styleKeyIndex = i;
-					} else if (!key.isHandlerKey) hasDynamicKey = true;
-				}
-				const classProp = propsExpression.properties[classKeyIndex];
-				const styleProp = propsExpression.properties[styleKeyIndex];
-				if (!hasDynamicKey) {
-					if (classProp && !isStaticExp(classProp.value)) classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]);
-					if (styleProp && (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || styleProp.value.type === 17)) styleProp.value = createCallExpression(context.helper(NORMALIZE_STYLE), [styleProp.value]);
-				} else propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [propsExpression]);
-				break;
-			case 14: break;
-			default:
-				propsExpression = createCallExpression(context.helper(NORMALIZE_PROPS), [createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [propsExpression])]);
-				break;
-		}
-		return {
-			props: propsExpression,
-			directives: runtimeDirectives,
-			patchFlag,
-			dynamicPropNames,
-			shouldUseBlock
-		};
-	}
-	function dedupeProperties(properties) {
-		const knownProps = /* @__PURE__ */ new Map();
-		const deduped = [];
-		for (let i = 0; i < properties.length; i++) {
-			const prop = properties[i];
-			if (prop.key.type === 8 || !prop.key.isStatic) {
-				deduped.push(prop);
-				continue;
-			}
-			const name = prop.key.content;
-			const existing = knownProps.get(name);
-			if (existing) {
-				if (name === "style" || name === "class" || shared.isOn(name)) mergeAsArray(existing, prop);
-			} else {
-				knownProps.set(name, prop);
-				deduped.push(prop);
-			}
-		}
-		return deduped;
-	}
-	function mergeAsArray(existing, incoming) {
-		if (existing.value.type === 17) existing.value.elements.push(incoming.value);
-		else existing.value = createArrayExpression([existing.value, incoming.value], existing.loc);
-	}
-	function buildDirectiveArgs(dir, context) {
-		const dirArgs = [];
-		const runtime = directiveImportMap.get(dir);
-		if (runtime) dirArgs.push(context.helperString(runtime));
-		else {
-			const fromSetup = resolveSetupReference("v-" + dir.name, context);
-			if (fromSetup) dirArgs.push(fromSetup);
-			else {
-				context.helper(RESOLVE_DIRECTIVE);
-				context.directives.add(dir.name);
-				dirArgs.push(toValidAssetId(dir.name, `directive`));
-			}
-		}
-		const { loc } = dir;
-		if (dir.exp) dirArgs.push(dir.exp);
-		if (dir.arg) {
-			if (!dir.exp) dirArgs.push(`void 0`);
-			dirArgs.push(dir.arg);
-		}
-		if (Object.keys(dir.modifiers).length) {
-			if (!dir.arg) {
-				if (!dir.exp) dirArgs.push(`void 0`);
-				dirArgs.push(`void 0`);
-			}
-			const trueExpression = createSimpleExpression(`true`, false, loc);
-			dirArgs.push(createObjectExpression(dir.modifiers.map((modifier) => createObjectProperty(modifier, trueExpression)), loc));
-		}
-		return createArrayExpression(dirArgs, dir.loc);
-	}
-	function stringifyDynamicPropNames(props) {
-		let propsNamesString = `[`;
-		for (let i = 0, l = props.length; i < l; i++) {
-			propsNamesString += JSON.stringify(props[i]);
-			if (i < l - 1) propsNamesString += ", ";
-		}
-		return propsNamesString + `]`;
-	}
-	function isComponentTag(tag) {
-		return tag === "component" || tag === "Component";
-	}
-	const transformSlotOutlet = (node, context) => {
-		if (isSlotOutlet(node)) {
-			const { children, loc } = node;
-			const { slotName, slotProps } = processSlotOutlet(node, context);
-			const slotArgs = [
-				context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
-				slotName,
-				"{}",
-				"undefined",
-				"true"
-			];
-			let expectedLen = 2;
-			if (slotProps) {
-				slotArgs[2] = slotProps;
-				expectedLen = 3;
-			}
-			if (children.length) {
-				slotArgs[3] = createFunctionExpression([], children, false, false, loc);
-				expectedLen = 4;
-			}
-			if (context.scopeId && !context.slotted) expectedLen = 5;
-			slotArgs.splice(expectedLen);
-			node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc);
-		}
-	};
-	function processSlotOutlet(node, context) {
-		let slotName = `"default"`;
-		let slotProps = void 0;
-		const nonNameProps = [];
-		for (let i = 0; i < node.props.length; i++) {
-			const p = node.props[i];
-			if (p.type === 6) {
-				if (p.value) if (p.name === "name") slotName = JSON.stringify(p.value.content);
-				else {
-					p.name = shared.camelize(p.name);
-					nonNameProps.push(p);
-				}
-			} else if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
-				if (p.exp) slotName = p.exp;
-				else if (p.arg && p.arg.type === 4) {
-					slotName = p.exp = createSimpleExpression(shared.camelize(p.arg.content), false, p.arg.loc);
-					slotName = p.exp = processExpression(p.exp, context);
-				}
-			} else {
-				if (p.name === "bind" && p.arg && isStaticExp(p.arg)) p.arg.content = shared.camelize(p.arg.content);
-				nonNameProps.push(p);
-			}
-		}
-		if (nonNameProps.length > 0) {
-			const { props, directives } = buildProps(node, context, nonNameProps, false, false);
-			slotProps = props;
-			if (directives.length) context.onError(createCompilerError(36, directives[0].loc));
-		}
-		return {
-			slotName,
-			slotProps
-		};
-	}
-	const transformOn = (dir, node, context, augmentor) => {
-		const { loc, modifiers, arg } = dir;
-		if (!dir.exp && !modifiers.length) context.onError(createCompilerError(35, loc));
-		let eventName;
-		if (arg.type === 4) if (arg.isStatic) {
-			let rawName = arg.content;
-			if (rawName.startsWith("vue:")) rawName = `vnode-${rawName.slice(4)}`;
-			eventName = createSimpleExpression(node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? shared.toHandlerKey(shared.camelize(rawName)) : `on:${rawName}`, true, arg.loc);
-		} else eventName = createCompoundExpression([
-			`${context.helperString(TO_HANDLER_KEY)}(`,
-			arg,
-			`)`
-		]);
-		else {
-			eventName = arg;
-			eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
-			eventName.children.push(`)`);
-		}
-		let exp = dir.exp;
-		if (exp && !exp.content.trim()) exp = void 0;
-		let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
-		if (exp) {
-			const isMemberExp = isMemberExpression(exp, context);
-			const isInlineStatement = !(isMemberExp || isFnExpression(exp, context));
-			const hasMultipleStatements = exp.content.includes(`;`);
-			if (context.prefixIdentifiers) {
-				isInlineStatement && context.addIdentifiers(`$event`);
-				exp = dir.exp = processExpression(exp, context, false, hasMultipleStatements);
-				isInlineStatement && context.removeIdentifiers(`$event`);
-				shouldCache = context.cacheHandlers && !context.inVOnce && !(exp.type === 4 && exp.constType > 0) && !(isMemberExp && node.tagType === 1) && !hasScopeRef(exp, context.identifiers);
-				if (shouldCache && isMemberExp) if (exp.type === 4) exp.content = `${exp.content} && ${exp.content}(...args)`;
-				else exp.children = [
-					...exp.children,
-					` && `,
-					...exp.children,
-					`(...args)`
-				];
-			}
-			if (isInlineStatement || shouldCache && isMemberExp) exp = createCompoundExpression([
-				`${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `
-//@ts-ignore
-` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
-				exp,
-				hasMultipleStatements ? `}` : `)`
-			]);
-		}
-		let ret = { props: [createObjectProperty(eventName, exp || createSimpleExpression(`() => {}`, false, loc))] };
-		if (augmentor) ret = augmentor(ret);
-		if (shouldCache) ret.props[0].value = context.cache(ret.props[0].value);
-		ret.props.forEach((p) => p.key.isHandlerKey = true);
-		return ret;
-	};
-	const transformBind = (dir, _node, context) => {
-		const { modifiers, loc } = dir;
-		const arg = dir.arg;
-		let { exp } = dir;
-		if (exp && exp.type === 4 && !exp.content.trim()) {
-			context.onError(createCompilerError(34, loc));
-			return { props: [createObjectProperty(arg, createSimpleExpression("", true, loc))] };
-		}
-		if (arg.type !== 4) {
-			arg.children.unshift(`(`);
-			arg.children.push(`) || ""`);
-		} else if (!arg.isStatic) arg.content = arg.content ? `${arg.content} || ""` : `""`;
-		if (modifiers.some((mod) => mod.content === "camel")) if (arg.type === 4) if (arg.isStatic) arg.content = shared.camelize(arg.content);
-		else arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
-		else {
-			arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
-			arg.children.push(`)`);
-		}
-		if (!context.inSSR) {
-			if (modifiers.some((mod) => mod.content === "prop")) injectPrefix(arg, ".");
-			if (modifiers.some((mod) => mod.content === "attr")) injectPrefix(arg, "^");
-		}
-		return { props: [createObjectProperty(arg, exp)] };
-	};
-	const injectPrefix = (arg, prefix) => {
-		if (arg.type === 4) if (arg.isStatic) arg.content = prefix + arg.content;
-		else arg.content = `\`${prefix}\${${arg.content}}\``;
-		else {
-			arg.children.unshift(`'${prefix}' + (`);
-			arg.children.push(`)`);
-		}
-	};
-	const transformText = (node, context) => {
-		if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) return () => {
-			const children = node.children;
-			let currentContainer = void 0;
-			let hasText = false;
-			for (let i = 0; i < children.length; i++) {
-				const child = children[i];
-				if (isText$1(child)) {
-					hasText = true;
-					for (let j = i + 1; j < children.length; j++) {
-						const next = children[j];
-						if (isText$1(next)) {
-							if (!currentContainer) currentContainer = children[i] = createCompoundExpression([child], child.loc);
-							currentContainer.children.push(` + `, next);
-							children.splice(j, 1);
-							j--;
-						} else {
-							currentContainer = void 0;
-							break;
-						}
-					}
-				}
-			}
-			if (!hasText || children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && !node.props.find((p) => p.type === 7 && !context.directiveTransforms[p.name]) && !(node.tag === "template"))) return;
-			for (let i = 0; i < children.length; i++) {
-				const child = children[i];
-				if (isText$1(child) || child.type === 8) {
-					const callArgs = [];
-					if (child.type !== 2 || child.content !== " ") callArgs.push(child);
-					if (!context.ssr && getConstantType(child, context) === 0) callArgs.push("1");
-					children[i] = {
-						type: 12,
-						content: child,
-						loc: child.loc,
-						codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs)
-					};
-				}
-			}
-		};
-	};
-	const seen$1 = /* @__PURE__ */ new WeakSet();
-	const transformOnce = (node, context) => {
-		if (node.type === 1 && findDir(node, "once", true)) {
-			if (seen$1.has(node) || context.inVOnce || context.inSSR) return;
-			seen$1.add(node);
-			context.inVOnce = true;
-			context.helper(SET_BLOCK_TRACKING);
-			return () => {
-				context.inVOnce = false;
-				const cur = context.currentNode;
-				if (cur.codegenNode) cur.codegenNode = context.cache(cur.codegenNode, true, true);
-			};
-		}
-	};
-	const transformModel = (dir, node, context) => {
-		const { exp, arg } = dir;
-		if (!exp) {
-			context.onError(createCompilerError(41, dir.loc));
-			return createTransformProps();
-		}
-		const rawExp = exp.loc.source.trim();
-		const expString = exp.type === 4 ? exp.content : rawExp;
-		const bindingType = context.bindingMetadata[rawExp];
-		if (bindingType === "props" || bindingType === "props-aliased") {
-			context.onError(createCompilerError(44, exp.loc));
-			return createTransformProps();
-		}
-		const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
-		if (!expString.trim() || !isMemberExpression(exp, context) && !maybeRef) {
-			context.onError(createCompilerError(42, exp.loc));
-			return createTransformProps();
-		}
-		if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {
-			context.onError(createCompilerError(43, exp.loc));
-			return createTransformProps();
-		}
-		const propName = arg ? arg : createSimpleExpression("modelValue", true);
-		const eventName = arg ? isStaticExp(arg) ? `onUpdate:${shared.camelize(arg.content)}` : createCompoundExpression(["\"onUpdate:\" + ", arg]) : `onUpdate:modelValue`;
-		let assignmentExp;
-		const eventArg = context.isTS ? `($event: any)` : `$event`;
-		if (maybeRef) if (bindingType === "setup-ref") assignmentExp = createCompoundExpression([
-			`${eventArg} => ((`,
-			createSimpleExpression(rawExp, false, exp.loc),
-			`).value = $event)`
-		]);
-		else {
-			const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`;
-			assignmentExp = createCompoundExpression([
-				`${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,
-				createSimpleExpression(rawExp, false, exp.loc),
-				`).value = $event : ${altAssignment})`
-			]);
-		}
-		else assignmentExp = createCompoundExpression([
-			`${eventArg} => ((`,
-			exp,
-			`) = $event)`
-		]);
-		const props = [createObjectProperty(propName, dir.exp), createObjectProperty(eventName, assignmentExp)];
-		if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) props[1].value = context.cache(props[1].value);
-		if (dir.modifiers.length && node.tagType === 1) {
-			const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
-			const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, " + \"Modifiers\""]) : `modelModifiers`;
-			props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2)));
-		}
-		return createTransformProps(props);
-	};
-	function createTransformProps(props = []) {
-		return { props };
-	}
-	const validDivisionCharRE = /[\w).+\-_$\]]/;
-	const transformFilter = (node, context) => {
-		if (!isCompatEnabled("COMPILER_FILTERS", context)) return;
-		if (node.type === 5) rewriteFilter(node.content, context);
-		else if (node.type === 1) node.props.forEach((prop) => {
-			if (prop.type === 7 && prop.name !== "for" && prop.exp) rewriteFilter(prop.exp, context);
-		});
-	};
-	function rewriteFilter(node, context) {
-		if (node.type === 4) parseFilter(node, context);
-		else for (let i = 0; i < node.children.length; i++) {
-			const child = node.children[i];
-			if (typeof child !== "object") continue;
-			if (child.type === 4) parseFilter(child, context);
-			else if (child.type === 8) rewriteFilter(node, context);
-			else if (child.type === 5) rewriteFilter(child.content, context);
-		}
-	}
-	function parseFilter(node, context) {
-		const exp = node.content;
-		let inSingle = false;
-		let inDouble = false;
-		let inTemplateString = false;
-		let inRegex = false;
-		let curly = 0;
-		let square = 0;
-		let paren = 0;
-		let lastFilterIndex = 0;
-		let c, prev, i, expression, filters = [];
-		for (i = 0; i < exp.length; i++) {
-			prev = c;
-			c = exp.charCodeAt(i);
-			if (inSingle) {
-				if (c === 39 && prev !== 92) inSingle = false;
-			} else if (inDouble) {
-				if (c === 34 && prev !== 92) inDouble = false;
-			} else if (inTemplateString) {
-				if (c === 96 && prev !== 92) inTemplateString = false;
-			} else if (inRegex) {
-				if (c === 47 && prev !== 92) inRegex = false;
-			} else if (c === 124 && exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) if (expression === void 0) {
-				lastFilterIndex = i + 1;
-				expression = exp.slice(0, i).trim();
-			} else pushFilter();
-			else {
-				switch (c) {
-					case 34:
-						inDouble = true;
-						break;
-					case 39:
-						inSingle = true;
-						break;
-					case 96:
-						inTemplateString = true;
-						break;
-					case 40:
-						paren++;
-						break;
-					case 41:
-						paren--;
-						break;
-					case 91:
-						square++;
-						break;
-					case 93:
-						square--;
-						break;
-					case 123:
-						curly++;
-						break;
-					case 125:
-						curly--;
-						break;
-				}
-				if (c === 47) {
-					let j = i - 1;
-					let p;
-					for (; j >= 0; j--) {
-						p = exp.charAt(j);
-						if (p !== " ") break;
-					}
-					if (!p || !validDivisionCharRE.test(p)) inRegex = true;
-				}
-			}
-		}
-		if (expression === void 0) expression = exp.slice(0, i).trim();
-		else if (lastFilterIndex !== 0) pushFilter();
-		function pushFilter() {
-			filters.push(exp.slice(lastFilterIndex, i).trim());
-			lastFilterIndex = i + 1;
-		}
-		if (filters.length) {
-			for (i = 0; i < filters.length; i++) expression = wrapFilter(expression, filters[i], context);
-			node.content = expression;
-			node.ast = void 0;
-		}
-	}
-	function wrapFilter(exp, filter, context) {
-		context.helper(RESOLVE_FILTER);
-		const i = filter.indexOf("(");
-		if (i < 0) {
-			context.filters.add(filter);
-			return `${toValidAssetId(filter, "filter")}(${exp})`;
-		} else {
-			const name = filter.slice(0, i);
-			const args = filter.slice(i + 1);
-			context.filters.add(name);
-			return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
-		}
-	}
-	const seen = /* @__PURE__ */ new WeakSet();
-	const transformMemo = (node, context) => {
-		if (node.type === 1) {
-			const dir = findDir(node, "memo");
-			if (!dir || seen.has(node) || context.inSSR) return;
-			seen.add(node);
-			return () => {
-				const codegenNode = node.codegenNode || context.currentNode.codegenNode;
-				if (codegenNode && codegenNode.type === 13) {
-					if (node.tagType !== 1) convertToBlock(codegenNode, context);
-					node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
-						dir.exp,
-						createFunctionExpression(void 0, codegenNode),
-						`_cache`,
-						String(context.cached.length)
-					]);
-					context.cached.push(null);
-				}
-			};
-		}
-	};
-	const transformVBindShorthand = (node, context) => {
-		if (node.type === 1) {
-			for (const prop of node.props) if (prop.type === 7 && prop.name === "bind" && !prop.exp) {
-				const arg = prop.arg;
-				if (arg.type !== 4 || !arg.isStatic) {
-					context.onError(createCompilerError(52, arg.loc));
-					prop.exp = createSimpleExpression("", true, arg.loc);
-				} else {
-					const propName = shared.camelize(arg.content);
-					if (validFirstIdentCharRE.test(propName[0]) || propName[0] === "-") prop.exp = createSimpleExpression(propName, false, arg.loc);
-				}
-			}
-		}
-	};
-	function getBaseTransformPreset(prefixIdentifiers) {
-		return [[
-			transformVBindShorthand,
-			transformOnce,
-			transformIf,
-			transformMemo,
-			transformFor,
-			...[transformFilter],
-			...prefixIdentifiers ? [trackVForSlotScopes, transformExpression] : [],
-			transformSlotOutlet,
-			transformElement,
-			trackSlotScopes,
-			transformText
-		], {
-			on: transformOn,
-			bind: transformBind,
-			model: transformModel
-		}];
-	}
-	function baseCompile(source, options = {}) {
-		const onError = options.onError || defaultOnError;
-		const isModuleMode = options.mode === "module";
-		const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
-		if (!prefixIdentifiers && options.cacheHandlers) onError(createCompilerError(49));
-		if (options.scopeId && !isModuleMode) onError(createCompilerError(50));
-		const resolvedOptions = shared.extend({}, options, { prefixIdentifiers });
-		const ast = shared.isString(source) ? baseParse(source, resolvedOptions) : source;
-		const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
-		if (options.isTS) {
-			const { expressionPlugins } = options;
-			if (!expressionPlugins || !expressionPlugins.includes("typescript")) options.expressionPlugins = [...expressionPlugins || [], "typescript"];
-		}
-		transform(ast, shared.extend({}, resolvedOptions, {
-			nodeTransforms: [...nodeTransforms, ...options.nodeTransforms || []],
-			directiveTransforms: shared.extend({}, directiveTransforms, options.directiveTransforms || {})
-		}));
-		return generate(ast, resolvedOptions);
-	}
-	const BindingTypes = {
-		"DATA": "data",
-		"PROPS": "props",
-		"PROPS_ALIASED": "props-aliased",
-		"SETUP_LET": "setup-let",
-		"SETUP_CONST": "setup-const",
-		"SETUP_REACTIVE_CONST": "setup-reactive-const",
-		"SETUP_MAYBE_REF": "setup-maybe-ref",
-		"SETUP_REF": "setup-ref",
-		"OPTIONS": "options",
-		"LITERAL_CONST": "literal-const"
-	};
-	const noopDirectiveTransform = () => ({ props: [] });
-	exports.generateCodeFrame = shared.generateCodeFrame;
-	exports.BASE_TRANSITION = BASE_TRANSITION;
-	exports.BindingTypes = BindingTypes;
-	exports.CAMELIZE = CAMELIZE;
-	exports.CAPITALIZE = CAPITALIZE;
-	exports.CREATE_BLOCK = CREATE_BLOCK;
-	exports.CREATE_COMMENT = CREATE_COMMENT;
-	exports.CREATE_ELEMENT_BLOCK = CREATE_ELEMENT_BLOCK;
-	exports.CREATE_ELEMENT_VNODE = CREATE_ELEMENT_VNODE;
-	exports.CREATE_SLOTS = CREATE_SLOTS;
-	exports.CREATE_STATIC = CREATE_STATIC;
-	exports.CREATE_TEXT = CREATE_TEXT;
-	exports.CREATE_VNODE = CREATE_VNODE;
-	exports.CompilerDeprecationTypes = CompilerDeprecationTypes;
-	exports.ConstantTypes = ConstantTypes;
-	exports.ElementTypes = ElementTypes;
-	exports.ErrorCodes = ErrorCodes;
-	exports.FRAGMENT = FRAGMENT;
-	exports.GUARD_REACTIVE_PROPS = GUARD_REACTIVE_PROPS;
-	exports.IS_MEMO_SAME = IS_MEMO_SAME;
-	exports.IS_REF = IS_REF;
-	exports.KEEP_ALIVE = KEEP_ALIVE;
-	exports.MERGE_PROPS = MERGE_PROPS;
-	exports.NORMALIZE_CLASS = NORMALIZE_CLASS;
-	exports.NORMALIZE_PROPS = NORMALIZE_PROPS;
-	exports.NORMALIZE_STYLE = NORMALIZE_STYLE;
-	exports.Namespaces = Namespaces;
-	exports.NodeTypes = NodeTypes;
-	exports.OPEN_BLOCK = OPEN_BLOCK;
-	exports.POP_SCOPE_ID = POP_SCOPE_ID;
-	exports.PUSH_SCOPE_ID = PUSH_SCOPE_ID;
-	exports.RENDER_LIST = RENDER_LIST;
-	exports.RENDER_SLOT = RENDER_SLOT;
-	exports.RESOLVE_COMPONENT = RESOLVE_COMPONENT;
-	exports.RESOLVE_DIRECTIVE = RESOLVE_DIRECTIVE;
-	exports.RESOLVE_DYNAMIC_COMPONENT = RESOLVE_DYNAMIC_COMPONENT;
-	exports.RESOLVE_FILTER = RESOLVE_FILTER;
-	exports.SET_BLOCK_TRACKING = SET_BLOCK_TRACKING;
-	exports.SUSPENSE = SUSPENSE;
-	exports.TELEPORT = TELEPORT;
-	exports.TO_DISPLAY_STRING = TO_DISPLAY_STRING;
-	exports.TO_HANDLERS = TO_HANDLERS;
-	exports.TO_HANDLER_KEY = TO_HANDLER_KEY;
-	exports.TS_NODE_TYPES = TS_NODE_TYPES;
-	exports.UNREF = UNREF;
-	exports.WITH_CTX = WITH_CTX;
-	exports.WITH_DIRECTIVES = WITH_DIRECTIVES;
-	exports.WITH_MEMO = WITH_MEMO;
-	exports.advancePositionWithClone = advancePositionWithClone;
-	exports.advancePositionWithMutation = advancePositionWithMutation;
-	exports.assert = assert;
-	exports.baseCompile = baseCompile;
-	exports.baseParse = baseParse;
-	exports.buildDirectiveArgs = buildDirectiveArgs;
-	exports.buildProps = buildProps;
-	exports.buildSlots = buildSlots;
-	exports.checkCompatEnabled = checkCompatEnabled;
-	exports.convertToBlock = convertToBlock;
-	exports.createArrayExpression = createArrayExpression;
-	exports.createAssignmentExpression = createAssignmentExpression;
-	exports.createBlockStatement = createBlockStatement;
-	exports.createCacheExpression = createCacheExpression;
-	exports.createCallExpression = createCallExpression;
-	exports.createCompilerError = createCompilerError;
-	exports.createCompoundExpression = createCompoundExpression;
-	exports.createConditionalExpression = createConditionalExpression;
-	exports.createForLoopParams = createForLoopParams;
-	exports.createFunctionExpression = createFunctionExpression;
-	exports.createIfStatement = createIfStatement;
-	exports.createInterpolation = createInterpolation;
-	exports.createObjectExpression = createObjectExpression;
-	exports.createObjectProperty = createObjectProperty;
-	exports.createReturnStatement = createReturnStatement;
-	exports.createRoot = createRoot;
-	exports.createSequenceExpression = createSequenceExpression;
-	exports.createSimpleExpression = createSimpleExpression;
-	exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;
-	exports.createTemplateLiteral = createTemplateLiteral;
-	exports.createTransformContext = createTransformContext;
-	exports.createVNodeCall = createVNodeCall;
-	exports.errorMessages = errorMessages;
-	exports.extractIdentifiers = extractIdentifiers;
-	exports.findDir = findDir;
-	exports.findProp = findProp;
-	exports.forAliasRE = forAliasRE;
-	exports.generate = generate;
-	exports.getBaseTransformPreset = getBaseTransformPreset;
-	exports.getConstantType = getConstantType;
-	exports.getMemoedVNodeCall = getMemoedVNodeCall;
-	exports.getVNodeBlockHelper = getVNodeBlockHelper;
-	exports.getVNodeHelper = getVNodeHelper;
-	exports.hasDynamicKeyVBind = hasDynamicKeyVBind;
-	exports.hasScopeRef = hasScopeRef;
-	exports.helperNameMap = helperNameMap;
-	exports.injectProp = injectProp;
-	exports.isCoreComponent = isCoreComponent;
-	exports.isFnExpression = isFnExpression;
-	exports.isFnExpressionBrowser = isFnExpressionBrowser;
-	exports.isFnExpressionNode = isFnExpressionNode;
-	exports.isFunctionType = isFunctionType;
-	exports.isInDestructureAssignment = isInDestructureAssignment;
-	exports.isInNewExpression = isInNewExpression;
-	exports.isMemberExpression = isMemberExpression;
-	exports.isMemberExpressionBrowser = isMemberExpressionBrowser;
-	exports.isMemberExpressionNode = isMemberExpressionNode;
-	exports.isReferencedIdentifier = isReferencedIdentifier;
-	exports.isSimpleIdentifier = isSimpleIdentifier;
-	exports.isSlotOutlet = isSlotOutlet;
-	exports.isStaticArgOf = isStaticArgOf;
-	exports.isStaticExp = isStaticExp;
-	exports.isStaticProperty = isStaticProperty;
-	exports.isStaticPropertyKey = isStaticPropertyKey;
-	exports.isTemplateNode = isTemplateNode;
-	exports.isText = isText$1;
-	exports.isVPre = isVPre;
-	exports.isVSlot = isVSlot;
-	exports.locStub = locStub;
-	exports.noopDirectiveTransform = noopDirectiveTransform;
-	exports.processExpression = processExpression;
-	exports.processFor = processFor;
-	exports.processIf = processIf;
-	exports.processSlotOutlet = processSlotOutlet;
-	exports.registerRuntimeHelpers = registerRuntimeHelpers;
-	exports.resolveComponentType = resolveComponentType;
-	exports.stringifyExpression = stringifyExpression;
-	exports.toValidAssetId = toValidAssetId;
-	exports.trackSlotScopes = trackSlotScopes;
-	exports.trackVForSlotScopes = trackVForSlotScopes;
-	exports.transform = transform;
-	exports.transformBind = transformBind;
-	exports.transformElement = transformElement;
-	exports.transformExpression = transformExpression;
-	exports.transformModel = transformModel;
-	exports.transformOn = transformOn;
-	exports.transformVBindShorthand = transformVBindShorthand;
-	exports.traverseNode = traverseNode;
-	exports.unwrapTSNode = unwrapTSNode;
-	exports.validFirstIdentCharRE = validFirstIdentCharRE;
-	exports.walkBlockDeclarations = walkBlockDeclarations;
-	exports.walkFunctionParams = walkFunctionParams;
-	exports.walkIdentifiers = walkIdentifiers;
-	exports.warnDeprecation = warnDeprecation;
-}) });
-
-//#endregion
-export default require_compiler_core_cjs_prod();
-
-export { require_compiler_core_cjs_prod };
-//# sourceMappingURL=compiler-core.cjs.prod.mjs.map