/**
  * @vue/compiler-dom v3.6.0-rc.10
  * (c) 2018-present Yuxi (Evan) You and Vue contributors
  * @license MIT
  **/
var VueCompilerDOM = (function(exports) {
	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
	//#region packages/shared/src/makeMap.ts
	/**
	* Make a map and return a function for checking if a key
	* is in that map.
	* IMPORTANT: all calls of this function must be prefixed with
	* \/\*#\_\_PURE\_\_\*\/
	* So that they can be tree-shaken if necessary.
	*/
	/*@__NO_SIDE_EFFECTS__*/
	function makeMap(str) {
		const map = Object.create(null);
		for (const key of str.split(",")) map[key] = 1;
		return (val) => val in map;
	}
	//#endregion
	//#region packages/shared/src/general.ts
	const EMPTY_OBJ = Object.freeze({});
	Object.freeze([]);
	const NOOP = () => {};
	/**
	* Always return false.
	*/
	const NO = () => false;
	const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
	const extend = Object.assign;
	const isArray = Array.isArray;
	const isString = (val) => typeof val === "string";
	const isSymbol = (val) => typeof val === "symbol";
	const isObject = (val) => val !== null && typeof val === "object";
	const isReservedProp = /*@__PURE__*/ makeMap(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted");
	const isBuiltInDirective = /*@__PURE__*/ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo");
	const cacheStringFunction = (fn) => {
		const cache = Object.create(null);
		return ((str) => {
			return cache[str] || (cache[str] = fn(str));
		});
	};
	const camelizeRE = /-(\w)/g;
	const camelizeReplacer = (_, c) => c ? c.toUpperCase() : "";
	/**
	* @private
	*/
	const camelize = cacheStringFunction((str) => str.replace(camelizeRE, camelizeReplacer));
	/**
	* @private
	*/
	const capitalize = cacheStringFunction((str) => {
		return str.charAt(0).toUpperCase() + str.slice(1);
	});
	/**
	* @private
	*/
	const toHandlerKey = cacheStringFunction((str) => {
		return str ? `on${capitalize(str)}` : ``;
	});
	/**
	* #13070 When v-model and v-model:model directives are used together,
	* they will generate the same modelModifiers prop,
	* so a `$` suffix is added to avoid conflicts.
	* @private
	*/
	const getModifierPropName = (name) => {
		return `${name === "modelValue" || name === "model-value" ? "model" : name}Modifiers${name === "model" ? "$" : ""}`;
	};
	//#endregion
	//#region packages/shared/src/patchFlags.ts
	/**
	* dev only flag -> name mapping
	*/
	const PatchFlagNames = {
		[1]: `TEXT`,
		[2]: `CLASS`,
		[4]: `STYLE`,
		[8]: `PROPS`,
		[16]: `FULL_PROPS`,
		[32]: `NEED_HYDRATION`,
		[64]: `STABLE_FRAGMENT`,
		[128]: `KEYED_FRAGMENT`,
		[256]: `UNKEYED_FRAGMENT`,
		[512]: `NEED_PATCH`,
		[1024]: `DYNAMIC_SLOTS`,
		[2048]: `DEV_ROOT_FRAGMENT`,
		[-1]: `CACHED`,
		[-2]: `BAIL`
	};
	//#endregion
	//#region packages/shared/src/slotFlags.ts
	/**
	* Dev only
	*/
	const slotFlagsText = {
		[1]: "STABLE",
		[2]: "DYNAMIC",
		[3]: "FORWARDED"
	};
	//#endregion
	//#region packages/shared/src/codeframe.ts
	const range = 2;
	function generateCodeFrame(source, start = 0, end = source.length) {
		start = Math.max(0, Math.min(start, source.length));
		end = Math.max(0, Math.min(end, source.length));
		if (start > end) return "";
		let lines = source.split(/(\r?\n)/);
		const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
		lines = lines.filter((_, idx) => idx % 2 === 0);
		let count = 0;
		const res = [];
		for (let i = 0; i < lines.length; i++) {
			count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
			if (count >= start) {
				for (let j = i - range; j <= i + range || end > count; j++) {
					if (j < 0 || j >= lines.length) continue;
					const line = j + 1;
					res.push(`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);
					const lineLength = lines[j].length;
					const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
					if (j === i) {
						const pad = start - (count - (lineLength + newLineSeqLength));
						const length = Math.max(1, end > count ? lineLength - pad : end - start);
						res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
					} else if (j > i) {
						if (end > count) {
							const length = Math.max(Math.min(end - count, lineLength), 1);
							res.push(`   |  ` + "^".repeat(length));
						}
						count += lineLength + newLineSeqLength;
					}
				}
				break;
			}
		}
		return res.join("\n");
	}
	//#endregion
	//#region packages/shared/src/normalizeProp.ts
	const listDelimiterRE = /;(?![^(]*\))/g;
	const propertyDelimiterRE = /:([^]+)/;
	const styleCommentRE = /"(?:[^"\\]|\\[^])*"|'(?:[^'\\]|\\[^])*'|\\[^]|\/\*[^]*?\*\//g;
	function parseStringStyle(cssText) {
		const ret = {};
		cssText.replace(styleCommentRE, (match) => match.startsWith("/*") ? "" : match).split(listDelimiterRE).forEach((item) => {
			if (item) {
				const tmp = item.split(propertyDelimiterRE);
				tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
			}
		});
		return ret;
	}
	//#endregion
	//#region packages/shared/src/domTagConfig.ts
	const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
	const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
	const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
	const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
	/**
	* Compiler only.
	* Do NOT use in runtime code paths unless behind `__DEV__` flag.
	*/
	const isHTMLTag = /*@__PURE__*/ makeMap(HTML_TAGS);
	/**
	* Compiler only.
	* Do NOT use in runtime code paths unless behind `__DEV__` flag.
	*/
	const isSVGTag = /*@__PURE__*/ makeMap(SVG_TAGS);
	/**
	* Compiler only.
	* Do NOT use in runtime code paths unless behind `__DEV__` flag.
	*/
	const isMathMLTag = /*@__PURE__*/ makeMap(MATH_TAGS);
	/**
	* Compiler only.
	* Do NOT use in runtime code paths unless behind `__DEV__` flag.
	*/
	const isVoidTag = /*@__PURE__*/ makeMap(VOID_TAGS);
	//#endregion
	//#region packages/compiler-core/src/runtimeHelpers.ts
	const FRAGMENT = Symbol(`Fragment`);
	const TELEPORT = Symbol(`Teleport`);
	const SUSPENSE = Symbol(`Suspense`);
	const KEEP_ALIVE = Symbol(`KeepAlive`);
	const BASE_TRANSITION = Symbol(`BaseTransition`);
	const OPEN_BLOCK = Symbol(`openBlock`);
	const CREATE_BLOCK = Symbol(`createBlock`);
	const CREATE_ELEMENT_BLOCK = Symbol(`createElementBlock`);
	const CREATE_VNODE = Symbol(`createVNode`);
	const CREATE_ELEMENT_VNODE = Symbol(`createElementVNode`);
	const CREATE_COMMENT = Symbol(`createCommentVNode`);
	const CREATE_TEXT = Symbol(`createTextVNode`);
	const CREATE_STATIC = Symbol(`createStaticVNode`);
	const RESOLVE_COMPONENT = Symbol(`resolveComponent`);
	const RESOLVE_DYNAMIC_COMPONENT = Symbol(`resolveDynamicComponent`);
	const RESOLVE_DIRECTIVE = Symbol(`resolveDirective`);
	const RESOLVE_FILTER = Symbol(`resolveFilter`);
	const WITH_DIRECTIVES = Symbol(`withDirectives`);
	const RENDER_LIST = Symbol(`renderList`);
	const RENDER_SLOT = Symbol(`renderSlot`);
	const CREATE_SLOTS = Symbol(`createSlots`);
	const TO_DISPLAY_STRING = Symbol(`toDisplayString`);
	const MERGE_PROPS = Symbol(`mergeProps`);
	const NORMALIZE_CLASS = Symbol(`normalizeClass`);
	const NORMALIZE_STYLE = Symbol(`normalizeStyle`);
	const NORMALIZE_PROPS = Symbol(`normalizeProps`);
	const GUARD_REACTIVE_PROPS = Symbol(`guardReactiveProps`);
	const TO_HANDLERS = Symbol(`toHandlers`);
	const CAMELIZE = Symbol(`camelize`);
	const CAPITALIZE = Symbol(`capitalize`);
	const TO_HANDLER_KEY = Symbol(`toHandlerKey`);
	const SET_BLOCK_TRACKING = Symbol(`setBlockTracking`);
	/**
	* @deprecated no longer needed in 3.5+ because we no longer hoist element nodes
	* but kept for backwards compat
	*/
	const PUSH_SCOPE_ID = Symbol(`pushScopeId`);
	/**
	* @deprecated kept for backwards compat
	*/
	const POP_SCOPE_ID = Symbol(`popScopeId`);
	const WITH_CTX = Symbol(`withCtx`);
	const UNREF = Symbol(`unref`);
	const IS_REF = Symbol(`isRef`);
	const WITH_MEMO = Symbol(`withMemo`);
	const IS_MEMO_SAME = Symbol(`isMemoSame`);
	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];
		});
	}
	//#endregion
	//#region packages/compiler-core/src/ast.ts
	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"
	};
	/**
	* Static types have several levels.
	* Higher levels implies lower levels. e.g. a node that can be stringified
	* can always be hoisted and skipped for patch.
	*/
	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 = false, loc = locStub) {
		if (context) {
			if (isBlock) {
				context.helper(OPEN_BLOCK);
				context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
			} else context.helper(getVNodeHelper(context.inSSR, isComponent));
			if (directives) context.helper(WITH_DIRECTIVES);
		}
		return {
			type: 13,
			tag,
			props,
			children,
			patchFlag,
			dynamicProps,
			directives,
			isBlock,
			disableTracking,
			isComponent,
			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: 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: 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) {
		return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
	}
	function getVNodeBlockHelper(ssr, isComponent) {
		return ssr || isComponent ? 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));
		}
	}
	//#endregion
	//#region packages/compiler-core/src/tokenizer.ts
	const defaultDelimitersOpen = new Uint8Array([123, 123]);
	const defaultDelimitersClose = new Uint8Array([125, 125]);
	/**
	* HTML only allows ASCII alpha characters (a-z and A-Z) at the beginning of a
	* tag name.
	*/
	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;
	}
	/**
	* Sequences used to match longer strings.
	*
	* We don't have `Script`, `Style`, or `Title` here. Instead, we re-use the *End
	* sequences with an increased offset.
	*/
	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 {
		get inSFCRoot() {
			return this.mode === 2 && this.stack.length === 0;
		}
		constructor(stack, cbs) {
			this.stack = stack;
			this.cbs = cbs;
			this.state = 1;
			this.buffer = "";
			this.sectionStart = 0;
			this.index = 0;
			this.entityStart = 0;
			this.baseState = 1;
			this.inRCDATA = false;
			this.inXML = false;
			this.inVPre = false;
			this.newlines = [];
			this.mode = 0;
			this.delimiterOpen = defaultDelimitersOpen;
			this.delimiterClose = defaultDelimitersClose;
			this.delimiterIndex = -1;
			this.currentSequence = void 0;
			this.sequenceIndex = 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;
			const length = this.newlines.length;
			let j = -1;
			if (length > 100) {
				let l = -1;
				let r = length;
				while (l + 1 < r) {
					const m = l + r >>> 1;
					this.newlines[m] < index ? l = m : r = m;
				}
				j = l;
			} else for (let i = length - 1; i >= 0; i--) if (index > this.newlines[i]) {
				j = i;
				break;
			}
			if (j >= 0) {
				line = j + 2;
				column = index - this.newlines[j];
			}
			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 (!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 (!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 || this.fastForwardTo(quote)) {
				this.cbs.onattribdata(this.sectionStart, this.index);
				this.sectionStart = -1;
				this.cbs.onattribend(quote === 34 ? 3 : 2, this.index + 1);
				this.state = 11;
			}
		}
		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);
		}
		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() {}
		stateInEntity() {}
		/**
		* 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();
				}
				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() {
			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) {}
	};
	//#endregion
	//#region packages/compiler-core/src/compat/compatConfig.ts
	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) {
		const enabled = isCompatEnabled(key, context);
		if (enabled) warnDeprecation(key, context, loc, ...args);
		return enabled;
	}
	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 ? `\n  Details: ${link}` : ``}`;
		const err = new SyntaxError(msg);
		err.code = key;
		if (loc) err.loc = loc;
		context.onWarn(err);
	}
	//#endregion
	//#region packages/compiler-core/src/errors.ts
	function defaultOnError(error) {
		throw error;
	}
	function defaultOnWarn(msg) {
		console.warn(`[Vue warn] ${msg.message}`);
	}
	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_V_MODEL_ON_CONST": 45,
		"45": "X_V_MODEL_ON_CONST",
		"X_INVALID_EXPRESSION": 46,
		"46": "X_INVALID_EXPRESSION",
		"X_KEEP_ALIVE_INVALID_CHILDREN": 47,
		"47": "X_KEEP_ALIVE_INVALID_CHILDREN",
		"X_PREFIX_ID_NOT_SUPPORTED": 48,
		"48": "X_PREFIX_ID_NOT_SUPPORTED",
		"X_MODULE_MODE_NOT_SUPPORTED": 49,
		"49": "X_MODULE_MODE_NOT_SUPPORTED",
		"X_CACHE_HANDLER_NOT_SUPPORTED": 50,
		"50": "X_CACHE_HANDLER_NOT_SUPPORTED",
		"X_SCOPE_ID_NOT_SUPPORTED": 51,
		"51": "X_SCOPE_ID_NOT_SUPPORTED",
		"X_VNODE_HOOKS": 52,
		"52": "X_VNODE_HOOKS",
		"X_V_BIND_INVALID_SAME_NAME_ARGUMENT": 53,
		"53": "X_V_BIND_INVALID_SAME_NAME_ARGUMENT",
		"__EXTEND_POINT__": 54,
		"54": "__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.`,
		[53]: `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.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.`,
		[45]: `v-model cannot be used on a const binding because it is not writable.`,
		[46]: `Error parsing JavaScript expression: `,
		[47]: `<KeepAlive> expects exactly one child component.`,
		[52]: `@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.`,
		[48]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
		[49]: `ES module mode is not supported in this build of compiler.`,
		[50]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
		[51]: `"scopeId" option is only supported in module mode.`,
		[54]: ``
	};
	//#endregion
	//#region packages/compiler-core/src/babelUtils.ts
	/**
	* Return value indicates whether the AST walked can be a constant
	*/
	function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = Object.create(null)) {}
	function isReferencedIdentifier(id, 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 stmt of cs.consequent) if (stmt.type === "VariableDeclaration" && (stmt.kind === "var" ? isVar : !isVar)) for (const decl of stmt.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);
		}
		return nodes;
	}
	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;
	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;
	}
	function isStaticNode(node) {
		node = unwrapTSNode(node);
		switch (node.type) {
			case "UnaryExpression": return isStaticNode(node.argument);
			case "LogicalExpression":
			case "BinaryExpression": return isStaticNode(node.left) && isStaticNode(node.right);
			case "ConditionalExpression": return isStaticNode(node.test) && isStaticNode(node.consequent) && isStaticNode(node.alternate);
			case "SequenceExpression":
			case "TemplateLiteral": return node.expressions.every((expr) => isStaticNode(expr));
			case "ParenthesizedExpression": return isStaticNode(node.expression);
			case "StringLiteral":
			case "NumericLiteral":
			case "BooleanLiteral":
			case "NullLiteral":
			case "BigIntLiteral": return true;
		}
		return false;
	}
	function isConstantNode(node, bindings) {
		if (isStaticNode(node)) return true;
		node = unwrapTSNode(node);
		switch (node.type) {
			case "Identifier": return bindings[node.name] === "literal-const";
			case "RegExpLiteral": return true;
			case "ObjectExpression": return node.properties.every((prop) => {
				if (prop.type === "ObjectMethod") return false;
				if (prop.type === "SpreadElement") return isConstantNode(prop.argument, bindings);
				return (!prop.computed || isConstantNode(prop.key, bindings)) && isConstantNode(prop.value, bindings);
			});
			case "ArrayExpression": return node.elements.every((element) => {
				if (element === null) return true;
				if (element.type === "SpreadElement") return isConstantNode(element.argument, bindings);
				return isConstantNode(element, bindings);
			});
		}
		return false;
	}
	//#endregion
	//#region packages/compiler-core/src/utils.ts
	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 MemberExpLexState = {
		"inMemberExp": 0,
		"0": "inMemberExp",
		"inBrackets": 1,
		"1": "inBrackets",
		"inParens": 2,
		"2": "inParens",
		"inString": 3,
		"3": "inString"
	};
	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;
	/**
	* Simple lexer to check if an expression is a member expression. This is
	* lax and only checks validity at the root level (i.e. does not validate exps
	* inside square brackets), but it's ok since these are only used on template
	* expressions and false positives are invalid expressions in the first place.
	*/
	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;
				}
			}
		}
		return !currentOpenBracketCount && !currentOpenParensCount;
	};
	const isMemberExpressionNode = NOOP;
	const isMemberExpression = isMemberExpressionBrowser;
	const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/;
	const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
	const isFnExpressionNode = NOOP;
	const isFnExpression = isFnExpressionBrowser;
	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) {
		/* v8 ignore next 3 */
		if (!condition) throw new Error(msg || `unexpected compiler condition`);
	}
	/** find directive */
	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) && (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(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 && !isString(props) && props.type === 14) {
			const callee = props.callee;
			if (!isString(callee) && propsHelperSet.has(callee)) return getUnnormalizedProps(props.arguments[0], callPath.concat(props));
		}
		return [props, callPath];
	}
	function injectProp(node, prop, context) {
		if (node.type !== 13 && injectSlotKey(node, prop)) return;
		let propsWithInjection;
		/**
		* 1. mergeProps(...)
		* 2. toHandlers(...)
		* 3. normalizeProps(...)
		* 4. normalizeProps(guardReactiveProps(...))
		*
		* we need to get the real props before normalization
		*/
		let props = node.type === 13 ? node.props : node.arguments[2];
		let callPath = [];
		let parentCall;
		if (props && !isString(props) && props.type === 14) {
			const ret = getUnnormalizedProps(props);
			props = ret[0];
			callPath = ret[1];
			parentCall = callPath[callPath.length - 1];
		}
		if (props == null || isString(props)) propsWithInjection = createObjectExpression([prop]);
		else if (props.type === 14) {
			const first = props.arguments[0];
			if (!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 injectSlotKey(node, prop) {
		var _node$arguments, _node$arguments2, _node$arguments3;
		if (prop.key.type !== 4 || prop.key.content !== "key") return false;
		const props = node.arguments[2];
		if (props && !isString(props)) {
			const [unnormalizedProps] = getUnnormalizedProps(props);
			if (unnormalizedProps && !isString(unnormalizedProps) && unnormalizedProps.type === 15 && hasProp(prop, unnormalizedProps)) return true;
		}
		(_node$arguments = node.arguments)[2] || (_node$arguments[2] = "{}");
		(_node$arguments2 = node.arguments)[3] || (_node$arguments2[3] = "undefined");
		(_node$arguments3 = node.arguments)[4] || (_node$arguments3[4] = "undefined");
		node.arguments[5] = prop.value;
		return true;
	}
	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) => 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;
	}
	function filterNonCommentChildren(node) {
		return node.children.filter((n) => !isCommentOrWhitespace(n));
	}
	function hasSingleChild(node) {
		return filterNonCommentChildren(node).length === 1;
	}
	function isSingleIfBlock(parent) {
		let hasEncounteredIf = false;
		for (const c of filterNonCommentChildren(parent)) if (c.type === 9 || c.type === 1 && findDir(c, "if")) {
			if (hasEncounteredIf) return false;
			hasEncounteredIf = true;
		} else if (!hasEncounteredIf || !(c.type === 1 && findDir(c, /^else(-if)?$/, true))) return false;
		return true;
	}
	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
	function isAllWhitespace(str) {
		for (let i = 0; i < str.length; i++) if (!isWhitespace(str.charCodeAt(i))) return false;
		return true;
	}
	function isWhitespaceText(node) {
		return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content);
	}
	function isCommentOrWhitespace(node) {
		return node.type === 3 || isWhitespaceText(node);
	}
	//#endregion
	//#region packages/compiler-core/src/parser.ts
	const defaultParserOptions = {
		parseMode: "base",
		ns: 0,
		delimiters: [`{{`, `}}`],
		getNamespace: () => 0,
		isVoidTag: NO,
		isPreTag: NO,
		isIgnoreNewlineTag: NO,
		isCustomElement: NO,
		onError: defaultOnError,
		onWarn: defaultOnWarn,
		comments: true,
		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 = currentOptions.decodeEntities(exp, false);
			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 (currentAttrValue.includes("&")) currentAttrValue = currentOptions.decodeEntities(currentAttrValue, true);
					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 {
						currentProp.exp = createExp(currentAttrValue, false, getLoc(currentAttrStartIndex, currentAttrEndIndex), 0, 0);
						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);
			}
			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] ? stack[0].ns : currentOptions.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 tag = stack[0] && stack[0].tag;
			if (tag !== "script" && tag !== "style" && content.includes("&")) content = currentOptions.decodeEntities(content, false);
		}
		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 = extend({}, el.children[el.children.length - 1].loc.end);
			else el.innerLoc.end = 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 (isCompatEnabled("COMPILER_V_IF_V_FOR_PRECEDENCE", currentOptions)) {
				let hasIf = false;
				let hasFor = false;
				for (let i = 0; i < props.length; i++) {
					const p = props[i];
					if (p.type === 7) {
						if (p.name === "if") hasIf = true;
						else if (p.name === "for") hasFor = true;
					}
					if (hasIf && hasFor) {
						warnDeprecation("COMPILER_V_IF_V_FOR_PRECEDENCE", currentOptions, el.loc);
						break;
					}
				}
			}
			if (!tokenizer.inSFCRoot && isCompatEnabled("COMPILER_NATIVE_TEMPLATE", currentOptions) && el.tag === "template" && !isFragmentTemplate(el)) {
				warnDeprecation("COMPILER_NATIVE_TEMPLATE", currentOptions, el.loc);
				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 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) {
		return createSimpleExpression(content, isStatic, loc, constType);
	}
	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 = extend({}, defaultParserOptions);
		if (options) {
			let key;
			for (key in options) if (options[key] != null) currentOptions[key] = options[key];
		}
		if (!currentOptions.decodeEntities) throw new Error(`[@vue/compiler-core] decodeEntities option is required in browser builds.`);
		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;
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/cacheStatic.ts
	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 /* ${PatchFlagNames[-1]} */`);
					toCache.push(child);
					continue;
				}
			}
			if (child.type === 1) {
				const isComponent = child.tagType === 1;
				if (isComponent) context.scopes.vSlot++;
				walk(child, node, context, false, inFor);
				if (isComponent) context.scopes.vSlot--;
			} else if (child.type === 11) walk(child, node, context, child.children.length === 1, true);
			else if (child.type === 9) for (let i = 0; i < child.branches.length; i++) walk(child.branches[i], node, context, child.branches[i].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 && 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 && !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 && !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(node, name) {
			if (node.children && !isArray(node.children) && node.children.type === 15) {
				const slot = node.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 returnType = 3;
					const generatedPropsType = getGeneratedPropsConstantType(node, context);
					if (generatedPropsType === 0) {
						constantCache.set(node, 0);
						return 0;
					}
					if (generatedPropsType < returnType) returnType = 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 < returnType) returnType = childType;
					}
					if (returnType > 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 < returnType) returnType = 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, returnType);
					return returnType;
				} 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 (isString(child) || 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 && !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;
	}
	//#endregion
	//#region packages/compiler-core/src/transform.ts
	function getSelfName(filename) {
		const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
		return nameMatch ? capitalize(camelize(nameMatch[1])) : null;
	}
	function createTransformContext(root, { filename = "", prefixIdentifiers = false, hoistStatic = false, hmr = false, cacheHandlers = false, nodeTransforms = [], directiveTransforms = {}, transformHoist = null, isBuiltInComponent = NOOP, isCustomElement = NOOP, expressionPlugins = [], scopeId = null, slotted = true, ssr = false, inSSR = false, ssrCssVars = ``, bindingMetadata = EMPTY_OBJ, inline = false, isTS = false, onError = defaultOnError, onWarn = defaultOnWarn, compatConfig }) {
		const context = {
			filename,
			selfName: getSelfName(filename),
			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(),
			vForMemoKeyedNodes: /* @__PURE__ */ new WeakSet(),
			temps: 0,
			identifiers: Object.create(null),
			identifierScopes: 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) {
				if (!context.currentNode) throw new Error(`Node being replaced is already removed.`);
				if (!context.parent) throw new Error(`Cannot replace root node.`);
				/* v8 ignore stop */
				context.parent.children[context.childIndex] = context.currentNode = node;
			},
			removeNode(node) {
				/* v8 ignore next 3 */
				if (!context.parent) throw new Error(`Cannot remove root node.`);
				const list = context.parent.children;
				const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
				/* v8 ignore next 3 */
				if (removalIndex < 0) throw new Error(`node being removed is not a child of current parent`);
				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: NOOP,
			addIdentifiers(exp, type = "local") {},
			removeIdentifiers(exp) {},
			isSlotScopeIdentifier(name) {
				const scopes = context.identifierScopes[name];
				return scopes ? scopes[scopes.length - 1] === "slot" : false;
			},
			hoist(exp) {
				if (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();
		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) {
			let patchFlag = 64;
			if (children.filter((c) => c.type !== 3).length === 1) patchFlag |= 2048;
			root.codegenNode = createVNodeCall(context, helper(FRAGMENT), void 0, root.children, patchFlag, 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 (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 i = 0; i < nodeTransforms.length; i++) {
			const onExit = nodeTransforms[i](node, context);
			if (onExit) {
				if (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 i = 0; i < node.branches.length; i++) traverseNode(node.branches[i], context);
				break;
			case 10:
			case 11:
			case 1:
			case 0: traverseChildren(node, context);
		}
		context.currentNode = node;
		let i = exitFns.length;
		while (i--) exitFns[i]();
	}
	function createStructuralDirectiveTransform(name, fn) {
		const matches = 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;
			}
		};
	}
	//#endregion
	//#region packages/compiler-core/src/codegen.ts
	const PURE_ANNOTATION = `/*@__PURE__*/`;
	const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
	const NewlineType = {
		"Start": 0,
		"0": "Start",
		"End": -1,
		"-1": "End",
		"None": -2,
		"-2": "None",
		"Unknown": -3,
		"-3": "Unknown"
	};
	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;
			},
			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);
		}
		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";
		genFunctionPreamble(ast, context);
		push(`function ${ssr ? `ssrRender` : `render`}(${(ssr ? [
			"_ctx",
			"_push",
			"_parent",
			"_attrs"
		] : ["_ctx", "_cache"]).join(", ")}) {`);
		indent();
		if (useWithBlock) {
			push(`with (_ctx) {`);
			indent();
			if (hasHelpers) {
				push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue\n`, -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(`\n`, 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: ``,
			map: context.map ? context.map.toJSON() : void 0,
			helpers: ast.helpers
		};
	}
	function genFunctionPreamble(ast, context) {
		const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context;
		const VueBinding = runtimeGlobalName;
		const helpers = Array.from(ast.helpers);
		if (helpers.length > 0) {
			push(`const _Vue = ${VueBinding}\n`, -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\n`, -1);
		}
		genHoists(ast.hoists, context);
		newline();
		push(`return `);
	}
	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 isText$1(n) {
		return 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) => isArray(n) || !isText$1(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 (isString(node)) push(node, -3);
			else if (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 (isString(node)) {
			context.push(node, -3);
			return;
		}
		if (isSymbol(node)) {
			context.push(context.helper(node));
			return;
		}
		switch (node.type) {
			case 1:
			case 9:
			case 11:
				assert(node.codegenNode != null, "Codegen node is missing for element/if/for node. Apply appropriate transforms first.");
				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: break;
			case 23: break;
			case 24: break;
			case 25: break;
			case 26: break;
			/* v8 ignore start */
			case 10: break;
			default:
				assert(false, `unhandled codegen node type: ${node.type}`);
				return node;
		}
	}
	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 (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 } = node;
		let patchFlagString;
		if (patchFlag) {
			if (patchFlag < 0) patchFlagString = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
			else patchFlagString = patchFlag + ` /* ${Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `)} */`;
		}
		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) : getVNodeHelper(context.inSSR, isComponent)) + `(`, -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 = 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 (isArray(params)) genNodeList(params, context);
		else if (params) genNode(params, context);
		push(`) => `);
		if (newline || body) {
			push(`{`);
			indent();
		}
		if (returns) {
			if (newline) push(`return `);
			if (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(`)]`);
	}
	//#endregion
	//#region packages/compiler-core/src/validateExpression.ts
	const prohibitedKeywordRE = new RegExp("\\b" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b") + "\\b");
	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
	/**
	* Validate a non-prefixed expression.
	* This is only called when using the in-browser runtime compiler since it
	* doesn't prefix expressions.
	*/
	function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {
		const exp = node.content;
		if (!exp.trim()) return;
		try {
			new Function(asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`);
		} catch (e) {
			let message = e.message;
			const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE);
			if (keywordMatch) message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`;
			context.onError(createCompilerError(46, node.loc, void 0, message));
		}
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/transformExpression.ts
	const isLiteralWhitelisted = /*@__PURE__*/ 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 && context.vForMemoKeyedNodes.has(node) && 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)) {
		validateBrowserExpression(node, context, asParams, asRawStatements);
		return node;
	}
	function stringifyExpression(exp) {
		if (isString(exp)) return exp;
		else if (exp.type === 4) return exp.content;
		else return exp.children.map(stringifyExpression).join("");
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/vIf.ts
	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 (dir.exp) validateBrowserExpression(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;
			const comments = [];
			let i = siblings.indexOf(node);
			while (i-- >= -1) {
				const sibling = siblings[i];
				if (sibling && isCommentOrWhitespace(sibling)) {
					context.removeNode(sibling);
					if (sibling.type === 3) comments.unshift(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);
					if (comments.length && !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) branch.children = [...comments, ...branch.children];
					{
						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), ["\"v-if\"", "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 {
				let patchFlag = 64;
				if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) patchFlag |= 2048;
				return createVNodeCall(context, helper(FRAGMENT), createObjectExpression([keyProperty]), children, patchFlag, 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;
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/vFor.ts
	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);
			keyProp && keyProp.type;
			let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
			const keyProperty = keyExp ? createObjectProperty(`key`, keyExp) : null;
			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);
					const shouldUseBlock = !isStableFragment || childBlock.isBlockRequired === true;
					if (childBlock.isBlock !== shouldUseBlock) {
						if (childBlock.isBlock) {
							removeHelper(OPEN_BLOCK);
							removeHelper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
						} else removeHelper(getVNodeHelper(context.inSSR, childBlock.isComponent));
					}
					childBlock.isBlock = shouldUseBlock;
					if (childBlock.isBlock) {
						helper(OPEN_BLOCK);
						helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
					} else {
						helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
						if (childBlock.needsPatch) {
							var _childBlock$patchFlag;
							childBlock.patchFlag = ((_childBlock$patchFlag = childBlock.patchFlag) !== null && _childBlock$patchFlag !== void 0 ? _childBlock$patchFlag : 0) | 512;
						}
					}
				}
				if (memo) {
					const loop = createFunctionExpression(createForLoopParams(forNode.parseResult, [createSimpleExpression(`_cached`)]));
					loop.body = createBlockStatement([
						createCompoundExpression([
							`const _memo = (`,
							memo.exp,
							`)`
						]),
						createCompoundExpression([
							`if (_cached && _cached.el`,
							...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++;
		const onExit = processCodegen && processCodegen(forNode);
		return () => {
			scopes.vFor--;
			if (onExit) onExit();
		};
	}
	function finalizeForParseResult(result, context) {
		if (result.finalized) return;
		validateBrowserExpression(result.source, context);
		if (result.key) validateBrowserExpression(result.key, context, true);
		if (result.index) validateBrowserExpression(result.index, context, true);
		if (result.value) validateBrowserExpression(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, i) => arg || createSimpleExpression(`_`.repeat(i + 1), false));
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/vSlot.ts
	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) {
				vSlot.exp;
				context.scopes.vSlot++;
				return () => {
					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;
		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 (!isCommentOrWhitespace(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, children) => {
				const fn = buildSlotFn(props, void 0, children, loc);
				if (context.compatConfig) fn.isNonScopedSlot = true;
				return createObjectProperty(`default`, fn);
			};
			if (!hasTemplateSlots) slotsProperties.push(buildDefaultSlotProperty(void 0, children));
			else if (implicitDefaultChildren.length && !implicitDefaultChildren.every(isWhitespaceText)) {
				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 + ` /* ${slotFlagsText[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;
			}
		}
		return false;
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/transformElement.ts
	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 = node.tagType === 1;
			let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
			const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
			let vnodeProps;
			let vnodeChildren;
			let patchFlag = 0;
			let vnodeDynamicProps;
			let dynamicPropNames;
			let vnodeDirectives;
			let needsPatch = false;
			let isBlockRequired = false;
			let shouldUseBlock = isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && (tag === "svg" || tag === "foreignObject" || tag === "math");
			if (props.length > 0) {
				const propsBuildResult = buildProps(node, context, void 0, isComponent, isDynamicComponent);
				vnodeProps = propsBuildResult.props;
				patchFlag = propsBuildResult.patchFlag;
				dynamicPropNames = propsBuildResult.dynamicPropNames;
				needsPatch = propsBuildResult.needsPatch;
				isBlockRequired = propsBuildResult.isBlockRequired;
				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 (node.children.length > 1) context.onError(createCompilerError(47, {
						start: node.children[0].loc.start,
						end: node.children[node.children.length - 1].loc.end,
						source: ""
					}));
				}
				if (isComponent && 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);
			const vnodeCall = node.codegenNode = createVNodeCall(context, vnodeTag, vnodeProps, vnodeChildren, patchFlag === 0 ? void 0 : patchFlag, vnodeDynamicProps, vnodeDirectives, !!shouldUseBlock, false, isComponent, node.loc);
			needsPatch = needsPatch && (patchFlag === 0 || patchFlag === 32);
			if (needsPatch) vnodeCall.needsPatch = true;
			if (isBlockRequired) vnodeCall.isBlockRequired = true;
		};
	};
	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);
				}
				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;
		}
		context.helper(RESOLVE_COMPONENT);
		context.components.add(tag);
		return toValidAssetId(tag, `component`);
	}
	function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
		const { tag, loc: elementLoc, children } = node;
		let properties = [];
		const mergeArgs = [];
		const runtimeDirectives = [];
		const hasChildren = children.length > 0;
		let shouldUseBlock = false;
		let isBlockRequired = 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 = isOn(name);
				if (isEventHandler && (!isComponent || isDynamicComponent) && name.toLowerCase() !== "onclick" && name !== "onUpdate:modelValue" && !isReservedProp(name)) hasHydrationEventBinding = true;
				if (isEventHandler && isReservedProp(name)) hasVnodeHook = true;
				if (name === "ref") hasRef = 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 === "class") hasClassBinding = true;
				else if (name === "style") hasStyleBinding = true;
				else if (name !== "ref" && name !== "key" && !dynamicPropNames.includes(name)) dynamicPropNames.push(name);
				if (isComponent && (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 (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) 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")) shouldUseBlock = true;
				if (isVOn && hasChildren && arg && isStaticExp(arg) && camelize(arg.content) === "vue:beforeUpdate") {
					shouldUseBlock = true;
					isBlockRequired = true;
				}
				if (isVBind && isStaticArgOf(arg, "ref")) pushRefVForMarker();
				if (!arg && (isVBind || isVOn)) {
					hasDynamicKeys = true;
					if (exp) {
						if (isVBind) {
							pushMergeArg();
							if (mergeArgs.some((arg) => {
								if (arg.type === 15) return arg.properties.some(({ key }) => {
									if (key.type !== 4 || !key.isStatic) return true;
									return key.content !== "class" && key.content !== "style" && !isOn(key.content);
								});
								else return true;
							})) checkCompatEnabled("COMPILER_V_BIND_OBJECT_ORDER", context, loc);
							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 ? [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, needRuntime } = directiveTransform(prop, node, context);
					!ssr && props.forEach(analyzePatchFlag);
					if (isVOn && arg && !isStaticExp(arg)) pushMergeArg(createObjectExpression(props, elementLoc));
					else properties.push(...props);
					if (needRuntime) {
						runtimeDirectives.push(prop);
						if (isSymbol(needRuntime)) directiveImportMap.set(prop, needRuntime);
					}
				} else if (!isBuiltInDirective(name)) {
					runtimeDirectives.push(prop);
					if (hasChildren) {
						shouldUseBlock = true;
						isBlockRequired = 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) patchFlag |= 2;
			if (hasStyleBinding && !isComponent) patchFlag |= 4;
			if (dynamicPropNames.length) patchFlag |= 8;
			if (hasHydrationEventBinding) patchFlag |= 32;
		}
		const needsPatch = (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0);
		if (!shouldUseBlock && needsPatch) 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])]);
		}
		return {
			props: propsExpression,
			directives: runtimeDirectives,
			patchFlag,
			dynamicPropNames,
			shouldUseBlock,
			needsPatch,
			isBlockRequired
		};
	}
	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" || 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 {
			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";
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/transformSlotOutlet.ts
	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 = 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(camelize(p.arg.content), false, p.arg.loc);
			} else {
				if (p.name === "bind" && p.arg && isStaticExp(p.arg)) p.arg.content = 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
		};
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/vOn.ts
	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("vnode")) context.onError(createCompilerError(52, arg.loc));
				if (rawName.startsWith("vue:")) rawName = `vnode-${rawName.slice(4)}`;
				eventName = createSimpleExpression(node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? toHandlerKey(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(`;`);
			validateBrowserExpression(exp, context, false, hasMultipleStatements);
			if (isInlineStatement || shouldCache && isMemberExp) exp = createCompoundExpression([
				`${isInlineStatement ? `$event` : `(...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;
	};
	//#endregion
	//#region packages/compiler-core/src/transforms/vBind.ts
	const transformBind = (dir, _node, context) => {
		const { modifiers, loc } = dir;
		const arg = dir.arg;
		let { exp } = dir;
		if (exp && exp.type === 4 && !exp.content.trim()) exp = void 0;
		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 = 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(`)`);
		}
	};
	//#endregion
	//#region packages/compiler-core/src/transforms/transformText.ts
	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(child)) {
					hasText = true;
					for (let j = i + 1; j < children.length; j++) {
						const next = children[j];
						if (isText(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(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 /* ${PatchFlagNames[1]} */`);
					children[i] = {
						type: 12,
						content: child,
						loc: child.loc,
						codegenNode: createCallExpression(context.helper(CREATE_TEXT), callArgs)
					};
				}
			}
		};
	};
	//#endregion
	//#region packages/compiler-core/src/transforms/vOnce.ts
	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);
			};
		}
	};
	//#endregion
	//#region packages/compiler-core/src/transforms/vModel.ts
	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();
		}
		if (bindingType === "literal-const" || bindingType === "setup-const") {
			context.onError(createCompilerError(45, exp.loc));
			return createTransformProps();
		}
		if (!expString.trim() || !isMemberExpression(exp, context) && true) {
			context.onError(createCompilerError(42, exp.loc));
			return createTransformProps();
		}
		const propName = arg ? arg : createSimpleExpression("modelValue", true);
		const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(["\"onUpdate:\" + ", arg]) : `onUpdate:modelValue`;
		let assignmentExp;
		assignmentExp = createCompoundExpression([
			`${context.isTS ? `($event: any)` : `$event`} => ((`,
			exp,
			`) = $event)`
		]);
		const props = [createObjectProperty(propName, dir.exp), createObjectProperty(eventName, assignmentExp)];
		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) ? getModifierPropName(arg.content) : createCompoundExpression([arg, " + \"Modifiers\""]) : `modelModifiers`;
			props.push(createObjectProperty(modifiersKey, createSimpleExpression(`{ ${modifiers} }`, false, dir.loc, 2)));
		}
		return createTransformProps(props);
	};
	function createTransformProps(props = []) {
		return { props };
	}
	//#endregion
	//#region packages/compiler-core/src/compat/transformFilter.ts
	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(child, 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--;
				}
				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) {
			warnDeprecation("COMPILER_FILTERS", context, node.loc);
			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}`;
		}
	}
	//#endregion
	//#region packages/compiler-core/src/transforms/vMemo.ts
	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);
				}
			};
		}
	};
	//#endregion
	//#region packages/compiler-core/src/transforms/transformVBindShorthand.ts
	const transformVBindShorthand = (node, context) => {
		if (node.type === 1) {
			for (const prop of node.props) if (prop.type === 7 && prop.name === "bind" && (!prop.exp || prop.exp.type === 4 && !prop.exp.content.trim()) && prop.arg) {
				const arg = prop.arg;
				if (arg.type !== 4 || !arg.isStatic) {
					context.onError(createCompilerError(53, arg.loc));
					prop.exp = createSimpleExpression("", true, arg.loc);
				} else {
					const propName = camelize(arg.content);
					if (validFirstIdentCharRE.test(propName[0]) || propName[0] === "-") prop.exp = createSimpleExpression(propName, false, arg.loc);
				}
			}
		}
	};
	//#endregion
	//#region packages/compiler-core/src/compile.ts
	function getBaseTransformPreset(prefixIdentifiers) {
		return [[
			transformVBindShorthand,
			transformOnce,
			transformIf,
			transformMemo,
			transformFor,
			...[transformFilter],
			...[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";
		if (options.prefixIdentifiers === true) onError(createCompilerError(48));
		else if (isModuleMode) onError(createCompilerError(49));
		/* v8 ignore stop */
		const prefixIdentifiers = false;
		if (options.cacheHandlers) onError(createCompilerError(50));
		if (options.scopeId && !isModuleMode) onError(createCompilerError(51));
		const resolvedOptions = extend({}, options, { prefixIdentifiers });
		const ast = isString(source) ? baseParse(source, resolvedOptions) : source;
		const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
		transform(ast, extend({}, resolvedOptions, {
			nodeTransforms: [...nodeTransforms, ...options.nodeTransforms || []],
			directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {})
		}));
		return generate(ast, resolvedOptions);
	}
	//#endregion
	//#region packages/compiler-core/src/options.ts
	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"
	};
	//#endregion
	//#region packages/compiler-core/src/transforms/noopDirectiveTransform.ts
	const noopDirectiveTransform = () => ({ props: [] });
	//#endregion
	//#region packages/compiler-dom/src/runtimeHelpers.ts
	const V_MODEL_RADIO = Symbol(`vModelRadio`);
	const V_MODEL_CHECKBOX = Symbol(`vModelCheckbox`);
	const V_MODEL_TEXT = Symbol(`vModelText`);
	const V_MODEL_SELECT = Symbol(`vModelSelect`);
	const V_MODEL_DYNAMIC = Symbol(`vModelDynamic`);
	const V_ON_WITH_MODIFIERS = Symbol(`vOnModifiersGuard`);
	const V_ON_WITH_KEYS = Symbol(`vOnKeysGuard`);
	const V_SHOW = Symbol(`vShow`);
	const TRANSITION = Symbol(`Transition`);
	const TRANSITION_GROUP = Symbol(`TransitionGroup`);
	registerRuntimeHelpers({
		[V_MODEL_RADIO]: `vModelRadio`,
		[V_MODEL_CHECKBOX]: `vModelCheckbox`,
		[V_MODEL_TEXT]: `vModelText`,
		[V_MODEL_SELECT]: `vModelSelect`,
		[V_MODEL_DYNAMIC]: `vModelDynamic`,
		[V_ON_WITH_MODIFIERS]: `withModifiers`,
		[V_ON_WITH_KEYS]: `withKeys`,
		[V_SHOW]: `vShow`,
		[TRANSITION]: `Transition`,
		[TRANSITION_GROUP]: `TransitionGroup`
	});
	//#endregion
	//#region packages/compiler-dom/src/decodeHtmlBrowser.ts
	let decoder;
	function decodeHtmlBrowser(raw, asAttr = false) {
		if (!decoder) decoder = document.createElement("div");
		if (asAttr) {
			decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
			return decoder.children[0].getAttribute("foo");
		} else {
			decoder.innerHTML = raw;
			return decoder.textContent;
		}
	}
	//#endregion
	//#region packages/compiler-dom/src/parserOptions.ts
	const parserOptions = {
		parseMode: "html",
		isVoidTag,
		isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
		isPreTag: (tag) => tag === "pre",
		isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
		decodeEntities: decodeHtmlBrowser,
		isBuiltInComponent: (tag) => {
			if (tag === "Transition" || tag === "transition") return TRANSITION;
			else if (tag === "TransitionGroup" || tag === "transition-group") return TRANSITION_GROUP;
		},
		getNamespace(tag, parent, rootNamespace) {
			let ns = parent ? parent.ns : rootNamespace;
			if (parent && ns === 2) {
				if (parent.tag === "annotation-xml") {
					if (isSVGTag(tag)) return 1;
					if (parent.props.some((a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml"))) ns = 0;
				} else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") ns = 0;
			} else if (parent && ns === 1) {
				if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") ns = 0;
			}
			if (ns === 0) {
				if (isSVGTag(tag)) return 1;
				if (isMathMLTag(tag)) return 2;
			}
			return ns;
		}
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/transformStyle.ts
	const transformStyle = (node) => {
		if (node.type === 1) node.props.forEach((p, i) => {
			if (p.type === 6 && p.name === "style" && p.value) node.props[i] = {
				type: 7,
				name: `bind`,
				arg: createSimpleExpression(`style`, true, p.loc),
				exp: parseInlineCSS(p.value.content, p.loc),
				modifiers: [],
				loc: p.loc
			};
		});
	};
	const parseInlineCSS = (cssText, loc) => {
		const normalized = parseStringStyle(cssText);
		return createSimpleExpression(JSON.stringify(normalized), false, loc, 3);
	};
	//#endregion
	//#region packages/compiler-dom/src/errors.ts
	function createDOMCompilerError(code, loc) {
		return createCompilerError(code, loc, DOMErrorMessages);
	}
	const DOMErrorCodes = {
		"X_V_HTML_NO_EXPRESSION": 54,
		"54": "X_V_HTML_NO_EXPRESSION",
		"X_V_HTML_WITH_CHILDREN": 55,
		"55": "X_V_HTML_WITH_CHILDREN",
		"X_V_TEXT_NO_EXPRESSION": 56,
		"56": "X_V_TEXT_NO_EXPRESSION",
		"X_V_TEXT_WITH_CHILDREN": 57,
		"57": "X_V_TEXT_WITH_CHILDREN",
		"X_V_MODEL_ON_INVALID_ELEMENT": 58,
		"58": "X_V_MODEL_ON_INVALID_ELEMENT",
		"X_V_MODEL_ARG_ON_ELEMENT": 59,
		"59": "X_V_MODEL_ARG_ON_ELEMENT",
		"X_V_MODEL_ON_FILE_INPUT_ELEMENT": 60,
		"60": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
		"X_V_MODEL_UNNECESSARY_VALUE": 61,
		"61": "X_V_MODEL_UNNECESSARY_VALUE",
		"X_V_SHOW_NO_EXPRESSION": 62,
		"62": "X_V_SHOW_NO_EXPRESSION",
		"X_TRANSITION_INVALID_CHILDREN": 63,
		"63": "X_TRANSITION_INVALID_CHILDREN",
		"X_IGNORED_SIDE_EFFECT_TAG": 64,
		"64": "X_IGNORED_SIDE_EFFECT_TAG",
		"__EXTEND_POINT__": 65,
		"65": "__EXTEND_POINT__"
	};
	const DOMErrorMessages = {
		[54]: `v-html is missing expression.`,
		[55]: `v-html will override element children.`,
		[56]: `v-text is missing expression.`,
		[57]: `v-text will override element children.`,
		[58]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
		[59]: `v-model argument is not supported on plain elements.`,
		[60]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
		[61]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
		[62]: `v-show is missing expression.`,
		[63]: `<Transition> expects exactly one child element or component.`,
		[64]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`,
		[65]: ``
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/vHtml.ts
	const transformVHtml = (dir, node, context) => {
		const { exp, loc } = dir;
		if (!exp) context.onError(createDOMCompilerError(54, loc));
		if (node.children.length) {
			context.onError(createDOMCompilerError(55, loc));
			node.children.length = 0;
		}
		return { props: [createObjectProperty(createSimpleExpression(`innerHTML`, true, loc), exp || createSimpleExpression("", true))] };
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/vText.ts
	const transformVText = (dir, node, context) => {
		const { exp, loc } = dir;
		if (!exp) context.onError(createDOMCompilerError(56, loc));
		if (node.children.length) {
			context.onError(createDOMCompilerError(57, loc));
			node.children.length = 0;
		}
		return { props: [createObjectProperty(createSimpleExpression(`textContent`, true), exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc) : createSimpleExpression("", true))] };
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/vModel.ts
	const transformModel$1 = (dir, node, context) => {
		const baseResult = transformModel(dir, node, context);
		if (!baseResult.props.length || node.tagType === 1) return baseResult;
		if (dir.arg) context.onError(createDOMCompilerError(59, dir.arg.loc));
		function checkDuplicatedValue() {
			const value = findDir(node, "bind");
			if (value && isStaticArgOf(value.arg, "value")) context.onError(createDOMCompilerError(61, value.loc));
		}
		const { tag } = node;
		const isCustomElement = context.isCustomElement(tag);
		if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
			let directiveToUse = V_MODEL_TEXT;
			let isInvalidType = false;
			if (tag === "input" || isCustomElement) {
				const type = findProp(node, `type`);
				if (type) {
					if (type.type === 7) directiveToUse = V_MODEL_DYNAMIC;
					else if (type.value) switch (type.value.content) {
						case "radio":
							directiveToUse = V_MODEL_RADIO;
							break;
						case "checkbox":
							directiveToUse = V_MODEL_CHECKBOX;
							break;
						case "file":
							isInvalidType = true;
							context.onError(createDOMCompilerError(60, dir.loc));
							break;
						default: checkDuplicatedValue();
					}
				} else if (hasDynamicKeyVBind(node)) directiveToUse = V_MODEL_DYNAMIC;
				else checkDuplicatedValue();
			} else if (tag === "select") directiveToUse = V_MODEL_SELECT;
			else checkDuplicatedValue();
			if (!isInvalidType) baseResult.needRuntime = context.helper(directiveToUse);
		} else context.onError(createDOMCompilerError(58, dir.loc));
		baseResult.props = baseResult.props.filter((p) => !(p.key.type === 4 && p.key.content === "modelValue"));
		return baseResult;
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/vOn.ts
	const isEventOptionModifier = /*@__PURE__*/ makeMap(`passive,once,capture`);
	const isNonKeyModifier = /*@__PURE__*/ makeMap("stop,prevent,self,ctrl,shift,alt,meta,exact,middle");
	const maybeKeyModifier = /*@__PURE__*/ makeMap("left,right");
	const isKeyboardEvent = /*@__PURE__*/ makeMap(`onkeyup,onkeydown,onkeypress`);
	const resolveModifiers = (key, modifiers, context, loc) => {
		const keyModifiers = [];
		const nonKeyModifiers = [];
		const eventOptionModifiers = [];
		for (let i = 0; i < modifiers.length; i++) {
			const modifier = modifiers[i].content;
			if (modifier === "delegate") {
				if (context) {
					const error = /* @__PURE__ */ new SyntaxError(`.delegate modifier is only supported in Vapor components.`);
					error.loc = modifiers[i].loc;
					context.onWarn(error);
				}
				continue;
			}
			if (modifier === "native" && context && checkCompatEnabled("COMPILER_V_ON_NATIVE", context, loc)) eventOptionModifiers.push(modifier);
			else if (isEventOptionModifier(modifier)) eventOptionModifiers.push(modifier);
			else {
				const keyString = isString(key) ? key : isStaticExp(key) ? key.content : null;
				if (maybeKeyModifier(modifier)) {
					if (keyString) {
						if (isKeyboardEvent(keyString.toLowerCase())) keyModifiers.push(modifier);
						else nonKeyModifiers.push(modifier);
					} else {
						keyModifiers.push(modifier);
						nonKeyModifiers.push(modifier);
					}
				} else if (isNonKeyModifier(modifier)) nonKeyModifiers.push(modifier);
				else keyModifiers.push(modifier);
			}
		}
		return {
			keyModifiers,
			nonKeyModifiers,
			eventOptionModifiers
		};
	};
	const transformClick = (key, event) => {
		return isStaticExp(key) && key.content.toLowerCase() === "onclick" ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
			`(`,
			key,
			`) === "onClick" ? "${event}" : (`,
			key,
			`)`
		]) : key;
	};
	const transformOn$1 = (dir, node, context) => {
		return transformOn(dir, node, context, (baseResult) => {
			const { modifiers } = dir;
			if (!modifiers.length) return baseResult;
			let { key, value: handlerExp } = baseResult.props[0];
			const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
			if (nonKeyModifiers.includes("right")) key = transformClick(key, `onContextmenu`);
			if (nonKeyModifiers.includes("middle")) key = transformClick(key, `onMouseup`);
			if (nonKeyModifiers.length) handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [handlerExp, JSON.stringify(nonKeyModifiers)]);
			if (keyModifiers.length && (!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [handlerExp, JSON.stringify(keyModifiers)]);
			if (eventOptionModifiers.length) {
				const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
				key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([
					`(`,
					key,
					`) + "${modifierPostfix}"`
				]);
			}
			return { props: [createObjectProperty(key, handlerExp)] };
		});
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/vShow.ts
	const transformShow = (dir, node, context) => {
		const { exp, loc } = dir;
		if (!exp) context.onError(createDOMCompilerError(62, loc));
		return {
			props: [],
			needRuntime: context.helper(V_SHOW)
		};
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/Transition.ts
	const transformTransition = (node, context) => {
		if (node.type === 1 && node.tagType === 1) {
			if (context.isBuiltInComponent(node.tag) === TRANSITION) return postTransformTransition(node, context.onError);
		}
	};
	function postTransformTransition(node, onError, hasMultipleChildren = defaultHasMultipleChildren) {
		return () => {
			if (!node.children.length) return;
			if (hasMultipleChildren(node)) onError(createDOMCompilerError(63, {
				start: node.children[0].loc.start,
				end: node.children[node.children.length - 1].loc.end,
				source: ""
			}));
			const child = node.children[0];
			if (child.type === 1 && !findDir(child, "if")) {
				for (const p of child.props) if (p.type === 7 && p.name === "show") node.props.push({
					type: 6,
					name: "persisted",
					nameLoc: node.loc,
					value: void 0,
					loc: node.loc
				});
			}
		};
	}
	function defaultHasMultipleChildren(node) {
		const children = node.children = node.children.filter((c) => !isCommentOrWhitespace(c));
		const child = children[0];
		return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(defaultHasMultipleChildren);
	}
	//#endregion
	//#region packages/compiler-dom/src/transforms/ignoreSideEffectTags.ts
	const ignoreSideEffectTags = (node, context) => {
		if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
			context.onError(createDOMCompilerError(64, node.loc));
			context.removeNode();
		}
	};
	//#endregion
	//#region packages/compiler-dom/src/htmlNesting.ts
	/**
	* Copied from https://github.com/MananTank/validate-html-nesting
	* with ISC license
	*
	* To avoid runtime dependency on validate-html-nesting
	* This file should not change very often in the original repo
	* but we may need to keep it up-to-date from time to time.
	*/
	/**
	* returns true if given parent-child nesting is valid HTML
	*/
	function isValidHTMLNesting(parent, child) {
		if (parent === "template") return true;
		if (parent in onlyValidChildren) return onlyValidChildren[parent].has(child);
		if (child in onlyValidParents) return onlyValidParents[child].has(parent);
		if (parent in knownInvalidChildren) {
			if (knownInvalidChildren[parent].has(child)) return false;
		}
		if (child in knownInvalidParents) {
			if (knownInvalidParents[child].has(parent)) return false;
		}
		return true;
	}
	const headings = /* @__PURE__ */ new Set([
		"h1",
		"h2",
		"h3",
		"h4",
		"h5",
		"h6"
	]);
	const emptySet = /* @__PURE__ */ new Set([]);
	/**
	* maps element to set of elements that can be it's children, no other */
	const onlyValidChildren = {
		head: /* @__PURE__ */ new Set([
			"base",
			"basefront",
			"bgsound",
			"link",
			"meta",
			"title",
			"noscript",
			"noframes",
			"style",
			"script",
			"template"
		]),
		optgroup: /* @__PURE__ */ new Set(["option"]),
		select: /* @__PURE__ */ new Set([
			"optgroup",
			"option",
			"hr"
		]),
		table: /* @__PURE__ */ new Set([
			"caption",
			"colgroup",
			"tbody",
			"tfoot",
			"thead"
		]),
		tr: /* @__PURE__ */ new Set(["td", "th"]),
		colgroup: /* @__PURE__ */ new Set(["col"]),
		tbody: /* @__PURE__ */ new Set(["tr"]),
		thead: /* @__PURE__ */ new Set(["tr"]),
		tfoot: /* @__PURE__ */ new Set(["tr"]),
		script: emptySet,
		iframe: emptySet,
		option: emptySet,
		textarea: emptySet,
		style: emptySet,
		title: emptySet
	};
	/** maps elements to set of elements which can be it's parent, no other */
	const onlyValidParents = {
		html: emptySet,
		body: /* @__PURE__ */ new Set(["html"]),
		head: /* @__PURE__ */ new Set(["html"]),
		td: /* @__PURE__ */ new Set(["tr"]),
		colgroup: /* @__PURE__ */ new Set(["table"]),
		caption: /* @__PURE__ */ new Set(["table"]),
		tbody: /* @__PURE__ */ new Set(["table"]),
		tfoot: /* @__PURE__ */ new Set(["table"]),
		col: /* @__PURE__ */ new Set(["colgroup"]),
		th: /* @__PURE__ */ new Set(["tr"]),
		thead: /* @__PURE__ */ new Set(["table"]),
		tr: /* @__PURE__ */ new Set([
			"tbody",
			"thead",
			"tfoot"
		]),
		dd: /* @__PURE__ */ new Set(["dl", "div"]),
		dt: /* @__PURE__ */ new Set(["dl", "div"]),
		figcaption: /* @__PURE__ */ new Set(["figure"]),
		summary: /* @__PURE__ */ new Set(["details"]),
		area: /* @__PURE__ */ new Set(["map"])
	};
	/** maps element to set of elements that can not be it's children, others can */
	const knownInvalidChildren = {
		p: /* @__PURE__ */ new Set([
			"address",
			"article",
			"aside",
			"blockquote",
			"center",
			"details",
			"dialog",
			"dir",
			"div",
			"dl",
			"fieldset",
			"figure",
			"footer",
			"form",
			"h1",
			"h2",
			"h3",
			"h4",
			"h5",
			"h6",
			"header",
			"hgroup",
			"hr",
			"li",
			"main",
			"nav",
			"menu",
			"ol",
			"p",
			"pre",
			"section",
			"table",
			"ul"
		]),
		svg: /* @__PURE__ */ new Set([
			"b",
			"blockquote",
			"br",
			"code",
			"dd",
			"div",
			"dl",
			"dt",
			"em",
			"embed",
			"h1",
			"h2",
			"h3",
			"h4",
			"h5",
			"h6",
			"hr",
			"i",
			"img",
			"li",
			"menu",
			"meta",
			"ol",
			"p",
			"pre",
			"ruby",
			"s",
			"small",
			"span",
			"strong",
			"sub",
			"sup",
			"table",
			"u",
			"ul",
			"var"
		])
	};
	/** maps element to set of elements that can not be it's parent, others can */
	const knownInvalidParents = {
		a: /* @__PURE__ */ new Set(["a"]),
		button: /* @__PURE__ */ new Set(["button"]),
		dd: /* @__PURE__ */ new Set(["dd", "dt"]),
		dt: /* @__PURE__ */ new Set(["dd", "dt"]),
		form: /* @__PURE__ */ new Set(["form"]),
		li: /* @__PURE__ */ new Set(["li"]),
		h1: headings,
		h2: headings,
		h3: headings,
		h4: headings,
		h5: headings,
		h6: headings
	};
	//#endregion
	//#region packages/compiler-dom/src/transforms/validateHtmlNesting.ts
	const validateHtmlNesting = (node, context) => {
		if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
			const error = /* @__PURE__ */ new SyntaxError(`<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`);
			error.loc = node.loc;
			context.onWarn(error);
		}
	};
	//#endregion
	//#region packages/compiler-dom/src/index.ts
	const DOMNodeTransforms = [transformStyle, ...[transformTransition, validateHtmlNesting]];
	const DOMDirectiveTransforms = {
		cloak: noopDirectiveTransform,
		html: transformVHtml,
		text: transformVText,
		model: transformModel$1,
		on: transformOn$1,
		show: transformShow
	};
	function compile(src, options = {}) {
		return baseCompile(src, extend({}, parserOptions, options, {
			nodeTransforms: [
				ignoreSideEffectTags,
				...DOMNodeTransforms,
				...options.nodeTransforms || []
			],
			directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
			transformHoist: null
		}));
	}
	function parse(template, options = {}) {
		return baseParse(template, extend({}, parserOptions, options));
	}
	//#endregion
	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.DOMDirectiveTransforms = DOMDirectiveTransforms;
	exports.DOMErrorCodes = DOMErrorCodes;
	exports.DOMErrorMessages = DOMErrorMessages;
	exports.DOMNodeTransforms = DOMNodeTransforms;
	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.MemberExpLexState = MemberExpLexState;
	exports.NORMALIZE_CLASS = NORMALIZE_CLASS;
	exports.NORMALIZE_PROPS = NORMALIZE_PROPS;
	exports.NORMALIZE_STYLE = NORMALIZE_STYLE;
	exports.NewlineType = NewlineType;
	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.TRANSITION = TRANSITION;
	exports.TRANSITION_GROUP = TRANSITION_GROUP;
	exports.TS_NODE_TYPES = TS_NODE_TYPES;
	exports.UNREF = UNREF;
	exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
	exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
	exports.V_MODEL_RADIO = V_MODEL_RADIO;
	exports.V_MODEL_SELECT = V_MODEL_SELECT;
	exports.V_MODEL_TEXT = V_MODEL_TEXT;
	exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
	exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
	exports.V_SHOW = V_SHOW;
	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.compile = compile;
	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.createDOMCompilerError = createDOMCompilerError;
	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.defaultOnError = defaultOnError;
	exports.defaultOnWarn = defaultOnWarn;
	exports.errorMessages = errorMessages;
	exports.extractIdentifiers = extractIdentifiers;
	exports.filterNonCommentChildren = filterNonCommentChildren;
	exports.findDir = findDir;
	exports.findProp = findProp;
	exports.forAliasRE = forAliasRE;
	exports.generate = generate;
	exports.generateCodeFrame = generateCodeFrame;
	exports.getBaseTransformPreset = getBaseTransformPreset;
	exports.getConstantType = getConstantType;
	exports.getMemoedVNodeCall = getMemoedVNodeCall;
	exports.getSelfName = getSelfName;
	exports.getVNodeBlockHelper = getVNodeBlockHelper;
	exports.getVNodeHelper = getVNodeHelper;
	exports.hasDynamicKeyVBind = hasDynamicKeyVBind;
	exports.hasScopeRef = hasScopeRef;
	exports.hasSingleChild = hasSingleChild;
	exports.helperNameMap = helperNameMap;
	exports.injectProp = injectProp;
	exports.isAllWhitespace = isAllWhitespace;
	exports.isCommentOrWhitespace = isCommentOrWhitespace;
	exports.isConstantNode = isConstantNode;
	exports.isCoreComponent = isCoreComponent;
	exports.isFnExpression = isFnExpression;
	exports.isFnExpressionBrowser = isFnExpressionBrowser;
	exports.isFnExpressionNode = isFnExpressionNode;
	exports.isFunctionType = isFunctionType;
	exports.isInDestructureAssignment = isInDestructureAssignment;
	exports.isInNewExpression = isInNewExpression;
	exports.isKeyboardEvent = isKeyboardEvent;
	exports.isLiteralWhitelisted = isLiteralWhitelisted;
	exports.isMemberExpression = isMemberExpression;
	exports.isMemberExpressionBrowser = isMemberExpressionBrowser;
	exports.isMemberExpressionNode = isMemberExpressionNode;
	exports.isReferencedIdentifier = isReferencedIdentifier;
	exports.isSimpleIdentifier = isSimpleIdentifier;
	exports.isSingleIfBlock = isSingleIfBlock;
	exports.isSlotOutlet = isSlotOutlet;
	exports.isStaticArgOf = isStaticArgOf;
	exports.isStaticExp = isStaticExp;
	exports.isStaticNode = isStaticNode;
	exports.isStaticProperty = isStaticProperty;
	exports.isStaticPropertyKey = isStaticPropertyKey;
	exports.isTemplateNode = isTemplateNode;
	exports.isText = isText;
	exports.isVPre = isVPre;
	exports.isVSlot = isVSlot;
	exports.isValidHTMLNesting = isValidHTMLNesting;
	exports.isWhitespaceText = isWhitespaceText;
	exports.locStub = locStub;
	exports.noopDirectiveTransform = noopDirectiveTransform;
	exports.parse = parse;
	exports.parserOptions = parserOptions;
	exports.postTransformTransition = postTransformTransition;
	exports.processExpression = processExpression;
	exports.processFor = processFor;
	exports.processIf = processIf;
	exports.processSlotOutlet = processSlotOutlet;
	exports.registerRuntimeHelpers = registerRuntimeHelpers;
	exports.resolveComponentType = resolveComponentType;
	exports.resolveModifiers = resolveModifiers;
	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.transformStyle = transformStyle;
	exports.transformVBindShorthand = transformVBindShorthand;
	exports.traverseNode = traverseNode;
	exports.unwrapTSNode = unwrapTSNode;
	exports.validFirstIdentCharRE = validFirstIdentCharRE;
	exports.walkBlockDeclarations = walkBlockDeclarations;
	exports.walkFunctionParams = walkFunctionParams;
	exports.walkIdentifiers = walkIdentifiers;
	exports.warnDeprecation = warnDeprecation;
	return exports;
})({});