/**
  * @vue/compiler-sfc v3.6.0-rc.10
  * (c) 2018-present Yuxi (Evan) You and Vue contributors
  * @license MIT
  **/
//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esmMin = (fn, res, err) => () => {
	if (err) throw err[0];
	try {
		return fn && (res = fn(fn = 0)), res;
	} catch (e) {
		throw err = [e], e;
	}
};
var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
var __exportAll = (all, no_symbols) => {
	let target = {};
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
	return target;
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: ((k) => from[k]).bind(null, key),
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
	if (typeof require !== "undefined") return require.apply(this, arguments);
	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
});
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/typeof.js
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
		return typeof o;
	} : function(o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
var init_typeof = __esmMin((() => {}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/toPrimitive.js
function toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) return t;
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) return i;
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
var init_toPrimitive = __esmMin((() => {
	init_typeof();
}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/toPropertyKey.js
function toPropertyKey(t) {
	var i = toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}
var init_toPropertyKey = __esmMin((() => {
	init_typeof();
	init_toPrimitive();
}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/defineProperty.js
function _defineProperty(e, r, t) {
	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
		value: t,
		enumerable: !0,
		configurable: !0,
		writable: !0
	}) : e[r] = t, e;
}
var init_defineProperty = __esmMin((() => {
	init_toPropertyKey();
}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/objectSpread2.js
function ownKeys(e, r) {
	var t = Object.keys(e);
	if (Object.getOwnPropertySymbols) {
		var o = Object.getOwnPropertySymbols(e);
		r && (o = o.filter(function(r) {
			return Object.getOwnPropertyDescriptor(e, r).enumerable;
		})), t.push.apply(t, o);
	}
	return t;
}
function _objectSpread2(e) {
	for (var r = 1; r < arguments.length; r++) {
		var t = null != arguments[r] ? arguments[r] : {};
		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
			_defineProperty(e, r, t[r]);
		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
		});
	}
	return e;
}
var init_objectSpread2 = __esmMin((() => {
	init_defineProperty();
}));
//#endregion
//#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 \0polyfill-node.global.js
var _polyfill_node_global_default;
var init__polyfill_node_global = __esmMin((() => {
	init__polyfill_node_global();
	_polyfill_node_global_default = typeof _polyfill_node_global_default !== "undefined" ? _polyfill_node_global_default : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
}));
//#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 isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
const isModelListener = (key) => key.startsWith("onUpdate:");
const extend = Object.assign;
const remove = (arr, el) => {
	const i = arr.indexOf(el);
	if (i > -1) arr.splice(i, 1);
};
const hasOwnProperty$3 = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty$3.call(val, key);
const isArray$3 = Array.isArray;
const isMap = (val) => toTypeString(val) === "[object Map]";
const isSet = (val) => toTypeString(val) === "[object Set]";
const isFunction$1 = (val) => typeof val === "function";
const isString$1 = (val) => typeof val === "string";
const isSymbol = (val) => typeof val === "symbol";
const isObject$2 = (val) => val !== null && typeof val === "object";
const objectToString$1 = Object.prototype.toString;
const toTypeString = (value) => objectToString$1.call(value);
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
const isReservedProp$1 = /*@__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));
const hyphenateRE = /\B([A-Z])/g;
/**
* @private
*/
const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
/**
* @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" ? "$" : ""}`;
};
const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
function genPropsAccessExp(name) {
	return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
}
function genCacheKey(source, options) {
	return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
}
function canSetValueDirectly(tagName) {
	return tagName !== "PROGRESS" && !tagName.includes("-");
}
//#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"
};
const isGloballyAllowed = /*@__PURE__*/ makeMap("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol");
//#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
function normalizeStyle(value) {
	if (isArray$3(value)) {
		const res = {};
		for (let i = 0; i < value.length; i++) {
			const item = value[i];
			const normalized = isString$1(item) ? parseStringStyle(item) : normalizeStyle(item);
			if (normalized) for (const key in normalized) res[key] = normalized[key];
		}
		return res;
	} else if (isString$1(value) || isObject$2(value)) return value;
}
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;
}
function stringifyStyle(styles) {
	if (!styles) return "";
	if (isString$1(styles)) return styles;
	let ret = "";
	for (const key in styles) {
		const value = styles[key];
		if (isString$1(value) || typeof value === "number") {
			const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
			ret += `${normalizedKey}:${value};`;
		}
	}
	return ret;
}
function normalizeClass(value) {
	let res = "";
	if (isString$1(value)) res = value;
	else if (isArray$3(value)) for (let i = 0; i < value.length; i++) {
		const normalized = normalizeClass(value[i]);
		if (normalized) res += normalized + " ";
	}
	else if (isObject$2(value)) {
		for (const name in value) if (value[name]) res += name + " ";
	}
	return res.trim();
}
//#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";
const FORMATTING_TAGS = "a,b,big,code,em,font,i,nobr,s,small,strike,strong,tt,u";
const ALWAYS_CLOSE_TAGS = "title,style,script,noscript,template,object,table,button,textarea,select,iframe,fieldset,form,foreignObject,desc,mi,mo,mn,ms,mtext,annotation-xml";
const INLINE_TAGS = "a,abbr,acronym,b,bdi,bdo,big,br,button,canvas,cite,code,data,datalist,del,dfn,em,embed,i,iframe,img,input,ins,kbd,label,map,mark,meter,noscript,object,output,picture,progress,q,ruby,s,samp,script,select,small,span,strong,sub,sup,svg,textarea,time,u,tt,var,video";
const BLOCK_TAGS = "address,article,aside,blockquote,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,header,hgroup,hr,li,main,menu,nav,ol,p,pre,section,table,ul";
/**
* 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);
/**
* Compiler only.
* Do NOT use in runtime code paths unless behind `__DEV__` flag.
*/
const isFormattingTag = /*@__PURE__*/ makeMap(FORMATTING_TAGS);
/**
* Compiler only.
* Do NOT use in runtime code paths unless behind `__DEV__` flag.
*/
const isAlwaysCloseTag = /*@__PURE__*/ makeMap(ALWAYS_CLOSE_TAGS);
/**
* Compiler only.
* Do NOT use in runtime code paths unless behind `__DEV__` flag.
*/
const isInlineTag = /*@__PURE__*/ makeMap(INLINE_TAGS);
/**
* Compiler only.
* Do NOT use in runtime code paths unless behind `__DEV__` flag.
*/
const isBlockTag = /*@__PURE__*/ makeMap(BLOCK_TAGS);
//#endregion
//#region packages/shared/src/domAttrConfig.ts
/**
* On the client we only need to offer special cases for boolean attributes that
* have different names from their corresponding dom properties:
* - itemscope -> N/A
* - allowfullscreen -> allowFullscreen
* - formnovalidate -> formNoValidate
* - ismap -> isMap
* - nomodule -> noModule
* - novalidate -> noValidate
* - readonly -> readOnly
*/
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /*@__PURE__*/ makeMap(specialBooleanAttrs);
/**
* The full list is needed during SSR to produce the correct initial markup.
*/
const isBooleanAttr = /*@__PURE__*/ makeMap(specialBooleanAttrs + ",async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected");
/**
* Boolean attributes should be included if the value is truthy or ''.
* e.g. `<select multiple>` compiles to `{ multiple: '' }`
*/
function includeBooleanAttr(value) {
	return !!value || value === "";
}
const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u000d\u0020]/;
const attrValidationCache = {};
function isSSRSafeAttrName(name) {
	if (attrValidationCache.hasOwnProperty(name)) return attrValidationCache[name];
	const isUnsafe = unsafeAttrCharRE.test(name);
	if (isUnsafe) console.error(`unsafe attribute name: ${name}`);
	return attrValidationCache[name] = !isUnsafe;
}
const propsToAttrMap = {
	acceptCharset: "accept-charset",
	className: "class",
	htmlFor: "for",
	httpEquiv: "http-equiv"
};
/**
* Known attributes, this is used for stringification of runtime static nodes
* so that we don't stringify bindings that cannot be set from HTML.
* Don't also forget to allow `data-*` and `aria-*`!
* Generated from https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes
*/
const isKnownHtmlAttr = /*@__PURE__*/ makeMap("accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap");
/**
* Generated from https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute
*/
const isKnownSvgAttr = /*@__PURE__*/ makeMap("xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan");
/**
* Generated from https://developer.mozilla.org/en-US/docs/Web/MathML/Attribute
*/
const isKnownMathMLAttr = /*@__PURE__*/ makeMap("accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns");
function shouldSetAsAttr(tagName, key) {
	if (key === "spellcheck" || key === "draggable" || key === "translate" || key === "autocorrect") return true;
	if (key === "form") return true;
	if (key === "list" && tagName === "INPUT") return true;
	if (key === "type" && tagName === "TEXTAREA") return true;
	if ((key === "width" || key === "height") && (tagName === "IMG" || tagName === "VIDEO" || tagName === "CANVAS" || tagName === "SOURCE")) return true;
	if (key === "sandbox" && tagName === "IFRAME") return true;
	return false;
}
//#endregion
//#region packages/shared/src/escapeHtml.ts
const escapeRE = /["'&<>]/;
function escapeHtml(string) {
	const str = "" + string;
	const match = escapeRE.exec(str);
	if (!match) return str;
	let html = "";
	let escaped;
	let index;
	let lastIndex = 0;
	for (index = match.index; index < str.length; index++) {
		switch (str.charCodeAt(index)) {
			case 34:
				escaped = "&quot;";
				break;
			case 38:
				escaped = "&amp;";
				break;
			case 39:
				escaped = "&#39;";
				break;
			case 60:
				escaped = "&lt;";
				break;
			case 62:
				escaped = "&gt;";
				break;
			default: continue;
		}
		if (lastIndex !== index) html += str.slice(lastIndex, index);
		lastIndex = index + 1;
		html += escaped;
	}
	return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
}
const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
function getEscapedCssVarName(key, doubleEscape) {
	return key.replace(cssVarNameEscapeSymbolsRE, (s) => doubleEscape ? s === "\"" ? "\\\\\\\"" : `\\\\${s}` : `\\${s}`);
}
//#endregion
//#region packages/shared/src/toDisplayString.ts
const isRef = (val) => {
	return !!(val && val["__v_isRef"] === true);
};
/**
* For converting {{ interpolation }} values to displayed strings.
* @private
*/
const toDisplayString = (val) => {
	switch (typeof val) {
		case "string": return val;
		case "object": if (val) {
			if (isRef(val)) return toDisplayString(val.value);
			else if (isArray$3(val) || val.toString === objectToString$1 || !isFunction$1(val.toString)) return JSON.stringify(val, replacer, 2);
		}
		default: return val == null ? "" : String(val);
	}
};
const replacer = (_key, val) => {
	if (isRef(val)) return replacer(_key, val.value);
	else if (isMap(val)) return { [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val], i) => {
		entries[stringifySymbol(key, i) + " =>"] = val;
		return entries;
	}, {}) };
	else if (isSet(val)) return { [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v)) };
	else if (isSymbol(val)) return stringifySymbol(val);
	else if (isObject$2(val) && !isArray$3(val) && !isPlainObject(val)) return String(val);
	return val;
};
const stringifySymbol = (v, i = "") => {
	var _description;
	return isSymbol(v) ? `Symbol(${(_description = v.description) !== null && _description !== void 0 ? _description : i})` : v;
};
//#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$1(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$1(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 node_modules/.pnpm/entities@7.0.1/node_modules/entities/dist/esm/decode-codepoint.js
var _a;
const decodeMap = /* @__PURE__ */ new Map([
	[0, 65533],
	[128, 8364],
	[130, 8218],
	[131, 402],
	[132, 8222],
	[133, 8230],
	[134, 8224],
	[135, 8225],
	[136, 710],
	[137, 8240],
	[138, 352],
	[139, 8249],
	[140, 338],
	[142, 381],
	[145, 8216],
	[146, 8217],
	[147, 8220],
	[148, 8221],
	[149, 8226],
	[150, 8211],
	[151, 8212],
	[152, 732],
	[153, 8482],
	[154, 353],
	[155, 8250],
	[156, 339],
	[158, 382],
	[159, 376]
]);
/**
* Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
*/
const fromCodePoint = (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : ((codePoint) => {
	let output = "";
	if (codePoint > 65535) {
		codePoint -= 65536;
		output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296);
		codePoint = 56320 | codePoint & 1023;
	}
	output += String.fromCharCode(codePoint);
	return output;
});
/**
* Replace the given code point with a replacement character if it is a
* surrogate or is outside the valid range. Otherwise return the code
* point unchanged.
*/
function replaceCodePoint(codePoint) {
	var _a;
	if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) return 65533;
	return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
}
//#endregion
//#region \0polyfill-node.buffer.js
function init() {
	inited = true;
	var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
	for (var i = 0, len = code.length; i < len; ++i) {
		lookup[i] = code[i];
		revLookup[code.charCodeAt(i)] = i;
	}
	revLookup["-".charCodeAt(0)] = 62;
	revLookup["_".charCodeAt(0)] = 63;
}
function toByteArray(b64) {
	if (!inited) init();
	var i, j, l, tmp, placeHolders, arr;
	var len = b64.length;
	if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
	placeHolders = b64[len - 2] === "=" ? 2 : b64[len - 1] === "=" ? 1 : 0;
	arr = new Arr(len * 3 / 4 - placeHolders);
	l = placeHolders > 0 ? len - 4 : len;
	var L = 0;
	for (i = 0, j = 0; i < l; i += 4, j += 3) {
		tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
		arr[L++] = tmp >> 16 & 255;
		arr[L++] = tmp >> 8 & 255;
		arr[L++] = tmp & 255;
	}
	if (placeHolders === 2) {
		tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
		arr[L++] = tmp & 255;
	} else if (placeHolders === 1) {
		tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
		arr[L++] = tmp >> 8 & 255;
		arr[L++] = tmp & 255;
	}
	return arr;
}
function tripletToBase64(num) {
	return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
}
function encodeChunk(uint8, start, end) {
	var tmp;
	var output = [];
	for (var i = start; i < end; i += 3) {
		tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
		output.push(tripletToBase64(tmp));
	}
	return output.join("");
}
function fromByteArray(uint8) {
	if (!inited) init();
	var tmp;
	var len = uint8.length;
	var extraBytes = len % 3;
	var output = "";
	var parts = [];
	var maxChunkLength = 16383;
	for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
	if (extraBytes === 1) {
		tmp = uint8[len - 1];
		output += lookup[tmp >> 2];
		output += lookup[tmp << 4 & 63];
		output += "==";
	} else if (extraBytes === 2) {
		tmp = (uint8[len - 2] << 8) + uint8[len - 1];
		output += lookup[tmp >> 10];
		output += lookup[tmp >> 4 & 63];
		output += lookup[tmp << 2 & 63];
		output += "=";
	}
	parts.push(output);
	return parts.join("");
}
function read(buffer, offset, isLE, mLen, nBytes) {
	var e, m;
	var eLen = nBytes * 8 - mLen - 1;
	var eMax = (1 << eLen) - 1;
	var eBias = eMax >> 1;
	var nBits = -7;
	var i = isLE ? nBytes - 1 : 0;
	var d = isLE ? -1 : 1;
	var s = buffer[offset + i];
	i += d;
	e = s & (1 << -nBits) - 1;
	s >>= -nBits;
	nBits += eLen;
	for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
	m = e & (1 << -nBits) - 1;
	e >>= -nBits;
	nBits += mLen;
	for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
	if (e === 0) e = 1 - eBias;
	else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
	else {
		m = m + Math.pow(2, mLen);
		e = e - eBias;
	}
	return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
}
function write(buffer, value, offset, isLE, mLen, nBytes) {
	var e, m, c;
	var eLen = nBytes * 8 - mLen - 1;
	var eMax = (1 << eLen) - 1;
	var eBias = eMax >> 1;
	var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
	var i = isLE ? 0 : nBytes - 1;
	var d = isLE ? 1 : -1;
	var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
	value = Math.abs(value);
	if (isNaN(value) || value === Infinity) {
		m = isNaN(value) ? 1 : 0;
		e = eMax;
	} else {
		e = Math.floor(Math.log(value) / Math.LN2);
		if (value * (c = Math.pow(2, -e)) < 1) {
			e--;
			c *= 2;
		}
		if (e + eBias >= 1) value += rt / c;
		else value += rt * Math.pow(2, 1 - eBias);
		if (value * c >= 2) {
			e++;
			c /= 2;
		}
		if (e + eBias >= eMax) {
			m = 0;
			e = eMax;
		} else if (e + eBias >= 1) {
			m = (value * c - 1) * Math.pow(2, mLen);
			e = e + eBias;
		} else {
			m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
			e = 0;
		}
	}
	for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8);
	e = e << mLen | m;
	eLen += mLen;
	for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8);
	buffer[offset + i - d] |= s * 128;
}
/*!
* The buffer module from node.js, for the browser.
*
* @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
* @license  MIT
*/
function kMaxLength() {
	return Buffer$1.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823;
}
function createBuffer(that, length) {
	if (kMaxLength() < length) throw new RangeError("Invalid typed array length");
	if (Buffer$1.TYPED_ARRAY_SUPPORT) {
		that = new Uint8Array(length);
		that.__proto__ = Buffer$1.prototype;
	} else {
		if (that === null) that = new Buffer$1(length);
		that.length = length;
	}
	return that;
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer$1(arg, encodingOrOffset, length) {
	if (!Buffer$1.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$1)) return new Buffer$1(arg, encodingOrOffset, length);
	if (typeof arg === "number") {
		if (typeof encodingOrOffset === "string") throw new Error("If encoding is specified then the first argument must be a string");
		return allocUnsafe(this, arg);
	}
	return from(this, arg, encodingOrOffset, length);
}
function from(that, value, encodingOrOffset, length) {
	if (typeof value === "number") throw new TypeError("\"value\" argument must not be a number");
	if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) return fromArrayBuffer(that, value, encodingOrOffset, length);
	if (typeof value === "string") return fromString(that, value, encodingOrOffset);
	return fromObject(that, value);
}
function assertSize(size) {
	if (typeof size !== "number") throw new TypeError("\"size\" argument must be a number");
	else if (size < 0) throw new RangeError("\"size\" argument must not be negative");
}
function alloc(that, size, fill, encoding) {
	assertSize(size);
	if (size <= 0) return createBuffer(that, size);
	if (fill !== void 0) return typeof encoding === "string" ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);
	return createBuffer(that, size);
}
function allocUnsafe(that, size) {
	assertSize(size);
	that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
	if (!Buffer$1.TYPED_ARRAY_SUPPORT) for (var i = 0; i < size; ++i) that[i] = 0;
	return that;
}
function fromString(that, string, encoding) {
	if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
	if (!Buffer$1.isEncoding(encoding)) throw new TypeError("\"encoding\" must be a valid string encoding");
	var length = byteLength(string, encoding) | 0;
	that = createBuffer(that, length);
	var actual = that.write(string, encoding);
	if (actual !== length) that = that.slice(0, actual);
	return that;
}
function fromArrayLike(that, array) {
	var length = array.length < 0 ? 0 : checked(array.length) | 0;
	that = createBuffer(that, length);
	for (var i = 0; i < length; i += 1) that[i] = array[i] & 255;
	return that;
}
function fromArrayBuffer(that, array, byteOffset, length) {
	array.byteLength;
	if (byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError("'offset' is out of bounds");
	if (array.byteLength < byteOffset + (length || 0)) throw new RangeError("'length' is out of bounds");
	if (byteOffset === void 0 && length === void 0) array = new Uint8Array(array);
	else if (length === void 0) array = new Uint8Array(array, byteOffset);
	else array = new Uint8Array(array, byteOffset, length);
	if (Buffer$1.TYPED_ARRAY_SUPPORT) {
		that = array;
		that.__proto__ = Buffer$1.prototype;
	} else that = fromArrayLike(that, array);
	return that;
}
function fromObject(that, obj) {
	if (internalIsBuffer(obj)) {
		var len = checked(obj.length) | 0;
		that = createBuffer(that, len);
		if (that.length === 0) return that;
		obj.copy(that, 0, 0, len);
		return that;
	}
	if (obj) {
		if (typeof ArrayBuffer !== "undefined" && obj.buffer instanceof ArrayBuffer || "length" in obj) {
			if (typeof obj.length !== "number" || isnan(obj.length)) return createBuffer(that, 0);
			return fromArrayLike(that, obj);
		}
		if (obj.type === "Buffer" && isArray$2(obj.data)) return fromArrayLike(that, obj.data);
	}
	throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.");
}
function checked(length) {
	if (length >= kMaxLength()) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength().toString(16) + " bytes");
	return length | 0;
}
function internalIsBuffer(b) {
	return !!(b != null && b._isBuffer);
}
function byteLength(string, encoding) {
	if (internalIsBuffer(string)) return string.length;
	if (typeof ArrayBuffer !== "undefined" && typeof ArrayBuffer.isView === "function" && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) return string.byteLength;
	if (typeof string !== "string") string = "" + string;
	var len = string.length;
	if (len === 0) return 0;
	var loweredCase = false;
	for (;;) switch (encoding) {
		case "ascii":
		case "latin1":
		case "binary": return len;
		case "utf8":
		case "utf-8":
		case void 0: return utf8ToBytes(string).length;
		case "ucs2":
		case "ucs-2":
		case "utf16le":
		case "utf-16le": return len * 2;
		case "hex": return len >>> 1;
		case "base64": return base64ToBytes(string).length;
		default:
			if (loweredCase) return utf8ToBytes(string).length;
			encoding = ("" + encoding).toLowerCase();
			loweredCase = true;
	}
}
function slowToString(encoding, start, end) {
	var loweredCase = false;
	if (start === void 0 || start < 0) start = 0;
	if (start > this.length) return "";
	if (end === void 0 || end > this.length) end = this.length;
	if (end <= 0) return "";
	end >>>= 0;
	start >>>= 0;
	if (end <= start) return "";
	if (!encoding) encoding = "utf8";
	while (true) switch (encoding) {
		case "hex": return hexSlice(this, start, end);
		case "utf8":
		case "utf-8": return utf8Slice(this, start, end);
		case "ascii": return asciiSlice(this, start, end);
		case "latin1":
		case "binary": return latin1Slice(this, start, end);
		case "base64": return base64Slice(this, start, end);
		case "ucs2":
		case "ucs-2":
		case "utf16le":
		case "utf-16le": return utf16leSlice(this, start, end);
		default:
			if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
			encoding = (encoding + "").toLowerCase();
			loweredCase = true;
	}
}
function swap(b, n, m) {
	var i = b[n];
	b[n] = b[m];
	b[m] = i;
}
function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
	if (buffer.length === 0) return -1;
	if (typeof byteOffset === "string") {
		encoding = byteOffset;
		byteOffset = 0;
	} else if (byteOffset > 2147483647) byteOffset = 2147483647;
	else if (byteOffset < -2147483648) byteOffset = -2147483648;
	byteOffset = +byteOffset;
	if (isNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
	if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
	if (byteOffset >= buffer.length) {
		if (dir) return -1;
		else byteOffset = buffer.length - 1;
	} else if (byteOffset < 0) {
		if (dir) byteOffset = 0;
		else return -1;
	}
	if (typeof val === "string") val = Buffer$1.from(val, encoding);
	if (internalIsBuffer(val)) {
		if (val.length === 0) return -1;
		return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
	} else if (typeof val === "number") {
		val = val & 255;
		if (Buffer$1.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === "function") {
			if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
			else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
		}
		return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
	}
	throw new TypeError("val must be string, number or Buffer");
}
function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
	var indexSize = 1;
	var arrLength = arr.length;
	var valLength = val.length;
	if (encoding !== void 0) {
		encoding = String(encoding).toLowerCase();
		if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
			if (arr.length < 2 || val.length < 2) return -1;
			indexSize = 2;
			arrLength /= 2;
			valLength /= 2;
			byteOffset /= 2;
		}
	}
	function read(buf, i) {
		if (indexSize === 1) return buf[i];
		else return buf.readUInt16BE(i * indexSize);
	}
	var i;
	if (dir) {
		var foundIndex = -1;
		for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
			if (foundIndex === -1) foundIndex = i;
			if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
		} else {
			if (foundIndex !== -1) i -= i - foundIndex;
			foundIndex = -1;
		}
	} else {
		if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
		for (i = byteOffset; i >= 0; i--) {
			var found = true;
			for (var j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
				found = false;
				break;
			}
			if (found) return i;
		}
	}
	return -1;
}
function hexWrite(buf, string, offset, length) {
	offset = Number(offset) || 0;
	var remaining = buf.length - offset;
	if (!length) length = remaining;
	else {
		length = Number(length);
		if (length > remaining) length = remaining;
	}
	var strLen = string.length;
	if (strLen % 2 !== 0) throw new TypeError("Invalid hex string");
	if (length > strLen / 2) length = strLen / 2;
	for (var i = 0; i < length; ++i) {
		var parsed = parseInt(string.substr(i * 2, 2), 16);
		if (isNaN(parsed)) return i;
		buf[offset + i] = parsed;
	}
	return i;
}
function utf8Write(buf, string, offset, length) {
	return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
}
function asciiWrite(buf, string, offset, length) {
	return blitBuffer(asciiToBytes(string), buf, offset, length);
}
function latin1Write(buf, string, offset, length) {
	return asciiWrite(buf, string, offset, length);
}
function base64Write(buf, string, offset, length) {
	return blitBuffer(base64ToBytes(string), buf, offset, length);
}
function ucs2Write(buf, string, offset, length) {
	return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
}
function base64Slice(buf, start, end) {
	if (start === 0 && end === buf.length) return fromByteArray(buf);
	else return fromByteArray(buf.slice(start, end));
}
function utf8Slice(buf, start, end) {
	end = Math.min(buf.length, end);
	var res = [];
	var i = start;
	while (i < end) {
		var firstByte = buf[i];
		var codePoint = null;
		var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
		if (i + bytesPerSequence <= end) {
			var secondByte, thirdByte, fourthByte, tempCodePoint;
			switch (bytesPerSequence) {
				case 1:
					if (firstByte < 128) codePoint = firstByte;
					break;
				case 2:
					secondByte = buf[i + 1];
					if ((secondByte & 192) === 128) {
						tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
						if (tempCodePoint > 127) codePoint = tempCodePoint;
					}
					break;
				case 3:
					secondByte = buf[i + 1];
					thirdByte = buf[i + 2];
					if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
						tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
						if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) codePoint = tempCodePoint;
					}
					break;
				case 4:
					secondByte = buf[i + 1];
					thirdByte = buf[i + 2];
					fourthByte = buf[i + 3];
					if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
						tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
						if (tempCodePoint > 65535 && tempCodePoint < 1114112) codePoint = tempCodePoint;
					}
			}
		}
		if (codePoint === null) {
			codePoint = 65533;
			bytesPerSequence = 1;
		} else if (codePoint > 65535) {
			codePoint -= 65536;
			res.push(codePoint >>> 10 & 1023 | 55296);
			codePoint = 56320 | codePoint & 1023;
		}
		res.push(codePoint);
		i += bytesPerSequence;
	}
	return decodeCodePointsArray(res);
}
function decodeCodePointsArray(codePoints) {
	var len = codePoints.length;
	if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
	var res = "";
	var i = 0;
	while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
	return res;
}
function asciiSlice(buf, start, end) {
	var ret = "";
	end = Math.min(buf.length, end);
	for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i] & 127);
	return ret;
}
function latin1Slice(buf, start, end) {
	var ret = "";
	end = Math.min(buf.length, end);
	for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i]);
	return ret;
}
function hexSlice(buf, start, end) {
	var len = buf.length;
	if (!start || start < 0) start = 0;
	if (!end || end < 0 || end > len) end = len;
	var out = "";
	for (var i = start; i < end; ++i) out += toHex(buf[i]);
	return out;
}
function utf16leSlice(buf, start, end) {
	var bytes = buf.slice(start, end);
	var res = "";
	for (var i = 0; i < bytes.length; i += 2) res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
	return res;
}
function checkOffset(offset, ext, length) {
	if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
	if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
}
function checkInt(buf, value, offset, ext, max, min) {
	if (!internalIsBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
	if (value > max || value < min) throw new RangeError("\"value\" argument is out of bounds");
	if (offset + ext > buf.length) throw new RangeError("Index out of range");
}
function objectWriteUInt16(buf, value, offset, littleEndian) {
	if (value < 0) value = 65535 + value + 1;
	for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) buf[offset + i] = (value & 255 << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;
}
function objectWriteUInt32(buf, value, offset, littleEndian) {
	if (value < 0) value = 4294967295 + value + 1;
	for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 255;
}
function checkIEEE754(buf, value, offset, ext, max, min) {
	if (offset + ext > buf.length) throw new RangeError("Index out of range");
	if (offset < 0) throw new RangeError("Index out of range");
}
function writeFloat(buf, value, offset, littleEndian, noAssert) {
	if (!noAssert) checkIEEE754(buf, value, offset, 4);
	write(buf, value, offset, littleEndian, 23, 4);
	return offset + 4;
}
function writeDouble(buf, value, offset, littleEndian, noAssert) {
	if (!noAssert) checkIEEE754(buf, value, offset, 8);
	write(buf, value, offset, littleEndian, 52, 8);
	return offset + 8;
}
function base64clean(str) {
	str = stringtrim(str).replace(INVALID_BASE64_RE, "");
	if (str.length < 2) return "";
	while (str.length % 4 !== 0) str = str + "=";
	return str;
}
function stringtrim(str) {
	if (str.trim) return str.trim();
	return str.replace(/^\s+|\s+$/g, "");
}
function toHex(n) {
	if (n < 16) return "0" + n.toString(16);
	return n.toString(16);
}
function utf8ToBytes(string, units) {
	units = units || Infinity;
	var codePoint;
	var length = string.length;
	var leadSurrogate = null;
	var bytes = [];
	for (var i = 0; i < length; ++i) {
		codePoint = string.charCodeAt(i);
		if (codePoint > 55295 && codePoint < 57344) {
			if (!leadSurrogate) {
				if (codePoint > 56319) {
					if ((units -= 3) > -1) bytes.push(239, 191, 189);
					continue;
				} else if (i + 1 === length) {
					if ((units -= 3) > -1) bytes.push(239, 191, 189);
					continue;
				}
				leadSurrogate = codePoint;
				continue;
			}
			if (codePoint < 56320) {
				if ((units -= 3) > -1) bytes.push(239, 191, 189);
				leadSurrogate = codePoint;
				continue;
			}
			codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
		} else if (leadSurrogate) {
			if ((units -= 3) > -1) bytes.push(239, 191, 189);
		}
		leadSurrogate = null;
		if (codePoint < 128) {
			if ((units -= 1) < 0) break;
			bytes.push(codePoint);
		} else if (codePoint < 2048) {
			if ((units -= 2) < 0) break;
			bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
		} else if (codePoint < 65536) {
			if ((units -= 3) < 0) break;
			bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
		} else if (codePoint < 1114112) {
			if ((units -= 4) < 0) break;
			bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
		} else throw new Error("Invalid code point");
	}
	return bytes;
}
function asciiToBytes(str) {
	var byteArray = [];
	for (var i = 0; i < str.length; ++i) byteArray.push(str.charCodeAt(i) & 255);
	return byteArray;
}
function utf16leToBytes(str, units) {
	var c, hi, lo;
	var byteArray = [];
	for (var i = 0; i < str.length; ++i) {
		if ((units -= 2) < 0) break;
		c = str.charCodeAt(i);
		hi = c >> 8;
		lo = c % 256;
		byteArray.push(lo);
		byteArray.push(hi);
	}
	return byteArray;
}
function base64ToBytes(str) {
	return toByteArray(base64clean(str));
}
function blitBuffer(src, dst, offset, length) {
	for (var i = 0; i < length; ++i) {
		if (i + offset >= dst.length || i >= src.length) break;
		dst[i + offset] = src[i];
	}
	return i;
}
function isnan(val) {
	return val !== val;
}
function isBuffer(obj) {
	return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj));
}
function isFastBuffer(obj) {
	return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
}
function isSlowBuffer(obj) {
	return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isFastBuffer(obj.slice(0, 0));
}
var lookup, revLookup, Arr, inited, toString$1, isArray$2, MAX_ARGUMENTS_LENGTH, INVALID_BASE64_RE;
var init__polyfill_node_buffer = __esmMin((() => {
	init__polyfill_node_global();
	lookup = [];
	revLookup = [];
	Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
	inited = false;
	toString$1 = {}.toString;
	isArray$2 = Array.isArray || function(arr) {
		return toString$1.call(arr) == "[object Array]";
	};
	/**
	* If `Buffer.TYPED_ARRAY_SUPPORT`:
	*   === true    Use Uint8Array implementation (fastest)
	*   === false   Use Object implementation (most compatible, even IE6)
	*
	* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
	* Opera 11.6+, iOS 4.2+.
	*
	* Due to various browser bugs, sometimes the Object implementation will be used even
	* when the browser supports typed arrays.
	*
	* Note:
	*
	*   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
	*     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
	*
	*   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
	*
	*   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
	*     incorrect length in some situations.
	
	* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
	* get the Object implementation, which is slower but behaves correctly.
	*/
	Buffer$1.TYPED_ARRAY_SUPPORT = _polyfill_node_global_default.TYPED_ARRAY_SUPPORT !== void 0 ? _polyfill_node_global_default.TYPED_ARRAY_SUPPORT : true;
	kMaxLength();
	Buffer$1.poolSize = 8192;
	Buffer$1._augment = function(arr) {
		arr.__proto__ = Buffer$1.prototype;
		return arr;
	};
	/**
	* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
	* if value is a number.
	* Buffer.from(str[, encoding])
	* Buffer.from(array)
	* Buffer.from(buffer)
	* Buffer.from(arrayBuffer[, byteOffset[, length]])
	**/
	Buffer$1.from = function(value, encodingOrOffset, length) {
		return from(null, value, encodingOrOffset, length);
	};
	if (Buffer$1.TYPED_ARRAY_SUPPORT) {
		Buffer$1.prototype.__proto__ = Uint8Array.prototype;
		Buffer$1.__proto__ = Uint8Array;
		if (typeof Symbol !== "undefined" && Symbol.species && Buffer$1[Symbol.species] === Buffer$1);
	}
	/**
	* Creates a new filled Buffer instance.
	* alloc(size[, fill[, encoding]])
	**/
	Buffer$1.alloc = function(size, fill, encoding) {
		return alloc(null, size, fill, encoding);
	};
	/**
	* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
	* */
	Buffer$1.allocUnsafe = function(size) {
		return allocUnsafe(null, size);
	};
	/**
	* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
	*/
	Buffer$1.allocUnsafeSlow = function(size) {
		return allocUnsafe(null, size);
	};
	Buffer$1.isBuffer = isBuffer;
	Buffer$1.compare = function compare(a, b) {
		if (!internalIsBuffer(a) || !internalIsBuffer(b)) throw new TypeError("Arguments must be Buffers");
		if (a === b) return 0;
		var x = a.length;
		var y = b.length;
		for (var i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
			x = a[i];
			y = b[i];
			break;
		}
		if (x < y) return -1;
		if (y < x) return 1;
		return 0;
	};
	Buffer$1.isEncoding = function isEncoding(encoding) {
		switch (String(encoding).toLowerCase()) {
			case "hex":
			case "utf8":
			case "utf-8":
			case "ascii":
			case "latin1":
			case "binary":
			case "base64":
			case "ucs2":
			case "ucs-2":
			case "utf16le":
			case "utf-16le": return true;
			default: return false;
		}
	};
	Buffer$1.concat = function concat(list, length) {
		if (!isArray$2(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
		if (list.length === 0) return Buffer$1.alloc(0);
		var i;
		if (length === void 0) {
			length = 0;
			for (i = 0; i < list.length; ++i) length += list[i].length;
		}
		var buffer = Buffer$1.allocUnsafe(length);
		var pos = 0;
		for (i = 0; i < list.length; ++i) {
			var buf = list[i];
			if (!internalIsBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
			buf.copy(buffer, pos);
			pos += buf.length;
		}
		return buffer;
	};
	Buffer$1.byteLength = byteLength;
	Buffer$1.prototype._isBuffer = true;
	Buffer$1.prototype.swap16 = function swap16() {
		var len = this.length;
		if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
		for (var i = 0; i < len; i += 2) swap(this, i, i + 1);
		return this;
	};
	Buffer$1.prototype.swap32 = function swap32() {
		var len = this.length;
		if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
		for (var i = 0; i < len; i += 4) {
			swap(this, i, i + 3);
			swap(this, i + 1, i + 2);
		}
		return this;
	};
	Buffer$1.prototype.swap64 = function swap64() {
		var len = this.length;
		if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
		for (var i = 0; i < len; i += 8) {
			swap(this, i, i + 7);
			swap(this, i + 1, i + 6);
			swap(this, i + 2, i + 5);
			swap(this, i + 3, i + 4);
		}
		return this;
	};
	Buffer$1.prototype.toString = function toString() {
		var length = this.length | 0;
		if (length === 0) return "";
		if (arguments.length === 0) return utf8Slice(this, 0, length);
		return slowToString.apply(this, arguments);
	};
	Buffer$1.prototype.equals = function equals(b) {
		if (!internalIsBuffer(b)) throw new TypeError("Argument must be a Buffer");
		if (this === b) return true;
		return Buffer$1.compare(this, b) === 0;
	};
	Buffer$1.prototype.inspect = function inspect() {
		var str = "";
		var max = 50;
		if (this.length > 0) {
			str = this.toString("hex", 0, max).match(/.{2}/g).join(" ");
			if (this.length > max) str += " ... ";
		}
		return "<Buffer " + str + ">";
	};
	Buffer$1.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
		if (!internalIsBuffer(target)) throw new TypeError("Argument must be a Buffer");
		if (start === void 0) start = 0;
		if (end === void 0) end = target ? target.length : 0;
		if (thisStart === void 0) thisStart = 0;
		if (thisEnd === void 0) thisEnd = this.length;
		if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError("out of range index");
		if (thisStart >= thisEnd && start >= end) return 0;
		if (thisStart >= thisEnd) return -1;
		if (start >= end) return 1;
		start >>>= 0;
		end >>>= 0;
		thisStart >>>= 0;
		thisEnd >>>= 0;
		if (this === target) return 0;
		var x = thisEnd - thisStart;
		var y = end - start;
		var len = Math.min(x, y);
		var thisCopy = this.slice(thisStart, thisEnd);
		var targetCopy = target.slice(start, end);
		for (var i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
			x = thisCopy[i];
			y = targetCopy[i];
			break;
		}
		if (x < y) return -1;
		if (y < x) return 1;
		return 0;
	};
	Buffer$1.prototype.includes = function includes(val, byteOffset, encoding) {
		return this.indexOf(val, byteOffset, encoding) !== -1;
	};
	Buffer$1.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
		return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
	};
	Buffer$1.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
		return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
	};
	Buffer$1.prototype.write = function write(string, offset, length, encoding) {
		if (offset === void 0) {
			encoding = "utf8";
			length = this.length;
			offset = 0;
		} else if (length === void 0 && typeof offset === "string") {
			encoding = offset;
			length = this.length;
			offset = 0;
		} else if (isFinite(offset)) {
			offset = offset | 0;
			if (isFinite(length)) {
				length = length | 0;
				if (encoding === void 0) encoding = "utf8";
			} else {
				encoding = length;
				length = void 0;
			}
		} else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
		var remaining = this.length - offset;
		if (length === void 0 || length > remaining) length = remaining;
		if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError("Attempt to write outside buffer bounds");
		if (!encoding) encoding = "utf8";
		var loweredCase = false;
		for (;;) switch (encoding) {
			case "hex": return hexWrite(this, string, offset, length);
			case "utf8":
			case "utf-8": return utf8Write(this, string, offset, length);
			case "ascii": return asciiWrite(this, string, offset, length);
			case "latin1":
			case "binary": return latin1Write(this, string, offset, length);
			case "base64": return base64Write(this, string, offset, length);
			case "ucs2":
			case "ucs-2":
			case "utf16le":
			case "utf-16le": return ucs2Write(this, string, offset, length);
			default:
				if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
				encoding = ("" + encoding).toLowerCase();
				loweredCase = true;
		}
	};
	Buffer$1.prototype.toJSON = function toJSON() {
		return {
			type: "Buffer",
			data: Array.prototype.slice.call(this._arr || this, 0)
		};
	};
	MAX_ARGUMENTS_LENGTH = 4096;
	Buffer$1.prototype.slice = function slice(start, end) {
		var len = this.length;
		start = ~~start;
		end = end === void 0 ? len : ~~end;
		if (start < 0) {
			start += len;
			if (start < 0) start = 0;
		} else if (start > len) start = len;
		if (end < 0) {
			end += len;
			if (end < 0) end = 0;
		} else if (end > len) end = len;
		if (end < start) end = start;
		var newBuf;
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			newBuf = this.subarray(start, end);
			newBuf.__proto__ = Buffer$1.prototype;
		} else {
			var sliceLen = end - start;
			newBuf = new Buffer$1(sliceLen, void 0);
			for (var i = 0; i < sliceLen; ++i) newBuf[i] = this[i + start];
		}
		return newBuf;
	};
	Buffer$1.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
		offset = offset | 0;
		byteLength = byteLength | 0;
		if (!noAssert) checkOffset(offset, byteLength, this.length);
		var val = this[offset];
		var mul = 1;
		var i = 0;
		while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
		return val;
	};
	Buffer$1.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
		offset = offset | 0;
		byteLength = byteLength | 0;
		if (!noAssert) checkOffset(offset, byteLength, this.length);
		var val = this[offset + --byteLength];
		var mul = 1;
		while (byteLength > 0 && (mul *= 256)) val += this[offset + --byteLength] * mul;
		return val;
	};
	Buffer$1.prototype.readUInt8 = function readUInt8(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 1, this.length);
		return this[offset];
	};
	Buffer$1.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 2, this.length);
		return this[offset] | this[offset + 1] << 8;
	};
	Buffer$1.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 2, this.length);
		return this[offset] << 8 | this[offset + 1];
	};
	Buffer$1.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 4, this.length);
		return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
	};
	Buffer$1.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 4, this.length);
		return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
	};
	Buffer$1.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
		offset = offset | 0;
		byteLength = byteLength | 0;
		if (!noAssert) checkOffset(offset, byteLength, this.length);
		var val = this[offset];
		var mul = 1;
		var i = 0;
		while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
		mul *= 128;
		if (val >= mul) val -= Math.pow(2, 8 * byteLength);
		return val;
	};
	Buffer$1.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
		offset = offset | 0;
		byteLength = byteLength | 0;
		if (!noAssert) checkOffset(offset, byteLength, this.length);
		var i = byteLength;
		var mul = 1;
		var val = this[offset + --i];
		while (i > 0 && (mul *= 256)) val += this[offset + --i] * mul;
		mul *= 128;
		if (val >= mul) val -= Math.pow(2, 8 * byteLength);
		return val;
	};
	Buffer$1.prototype.readInt8 = function readInt8(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 1, this.length);
		if (!(this[offset] & 128)) return this[offset];
		return (255 - this[offset] + 1) * -1;
	};
	Buffer$1.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 2, this.length);
		var val = this[offset] | this[offset + 1] << 8;
		return val & 32768 ? val | 4294901760 : val;
	};
	Buffer$1.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 2, this.length);
		var val = this[offset + 1] | this[offset] << 8;
		return val & 32768 ? val | 4294901760 : val;
	};
	Buffer$1.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 4, this.length);
		return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
	};
	Buffer$1.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 4, this.length);
		return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
	};
	Buffer$1.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 4, this.length);
		return read(this, offset, true, 23, 4);
	};
	Buffer$1.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 4, this.length);
		return read(this, offset, false, 23, 4);
	};
	Buffer$1.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 8, this.length);
		return read(this, offset, true, 52, 8);
	};
	Buffer$1.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
		if (!noAssert) checkOffset(offset, 8, this.length);
		return read(this, offset, false, 52, 8);
	};
	Buffer$1.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
		value = +value;
		offset = offset | 0;
		byteLength = byteLength | 0;
		if (!noAssert) {
			var maxBytes = Math.pow(2, 8 * byteLength) - 1;
			checkInt(this, value, offset, byteLength, maxBytes, 0);
		}
		var mul = 1;
		var i = 0;
		this[offset] = value & 255;
		while (++i < byteLength && (mul *= 256)) this[offset + i] = value / mul & 255;
		return offset + byteLength;
	};
	Buffer$1.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
		value = +value;
		offset = offset | 0;
		byteLength = byteLength | 0;
		if (!noAssert) {
			var maxBytes = Math.pow(2, 8 * byteLength) - 1;
			checkInt(this, value, offset, byteLength, maxBytes, 0);
		}
		var i = byteLength - 1;
		var mul = 1;
		this[offset + i] = value & 255;
		while (--i >= 0 && (mul *= 256)) this[offset + i] = value / mul & 255;
		return offset + byteLength;
	};
	Buffer$1.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
		if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
		this[offset] = value & 255;
		return offset + 1;
	};
	Buffer$1.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value & 255;
			this[offset + 1] = value >>> 8;
		} else objectWriteUInt16(this, value, offset, true);
		return offset + 2;
	};
	Buffer$1.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value >>> 8;
			this[offset + 1] = value & 255;
		} else objectWriteUInt16(this, value, offset, false);
		return offset + 2;
	};
	Buffer$1.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset + 3] = value >>> 24;
			this[offset + 2] = value >>> 16;
			this[offset + 1] = value >>> 8;
			this[offset] = value & 255;
		} else objectWriteUInt32(this, value, offset, true);
		return offset + 4;
	};
	Buffer$1.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value >>> 24;
			this[offset + 1] = value >>> 16;
			this[offset + 2] = value >>> 8;
			this[offset + 3] = value & 255;
		} else objectWriteUInt32(this, value, offset, false);
		return offset + 4;
	};
	Buffer$1.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) {
			var limit = Math.pow(2, 8 * byteLength - 1);
			checkInt(this, value, offset, byteLength, limit - 1, -limit);
		}
		var i = 0;
		var mul = 1;
		var sub = 0;
		this[offset] = value & 255;
		while (++i < byteLength && (mul *= 256)) {
			if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
			this[offset + i] = (value / mul >> 0) - sub & 255;
		}
		return offset + byteLength;
	};
	Buffer$1.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) {
			var limit = Math.pow(2, 8 * byteLength - 1);
			checkInt(this, value, offset, byteLength, limit - 1, -limit);
		}
		var i = byteLength - 1;
		var mul = 1;
		var sub = 0;
		this[offset + i] = value & 255;
		while (--i >= 0 && (mul *= 256)) {
			if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
			this[offset + i] = (value / mul >> 0) - sub & 255;
		}
		return offset + byteLength;
	};
	Buffer$1.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
		if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
		if (value < 0) value = 255 + value + 1;
		this[offset] = value & 255;
		return offset + 1;
	};
	Buffer$1.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value & 255;
			this[offset + 1] = value >>> 8;
		} else objectWriteUInt16(this, value, offset, true);
		return offset + 2;
	};
	Buffer$1.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value >>> 8;
			this[offset + 1] = value & 255;
		} else objectWriteUInt16(this, value, offset, false);
		return offset + 2;
	};
	Buffer$1.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value & 255;
			this[offset + 1] = value >>> 8;
			this[offset + 2] = value >>> 16;
			this[offset + 3] = value >>> 24;
		} else objectWriteUInt32(this, value, offset, true);
		return offset + 4;
	};
	Buffer$1.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
		value = +value;
		offset = offset | 0;
		if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
		if (value < 0) value = 4294967295 + value + 1;
		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
			this[offset] = value >>> 24;
			this[offset + 1] = value >>> 16;
			this[offset + 2] = value >>> 8;
			this[offset + 3] = value & 255;
		} else objectWriteUInt32(this, value, offset, false);
		return offset + 4;
	};
	Buffer$1.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
		return writeFloat(this, value, offset, true, noAssert);
	};
	Buffer$1.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
		return writeFloat(this, value, offset, false, noAssert);
	};
	Buffer$1.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
		return writeDouble(this, value, offset, true, noAssert);
	};
	Buffer$1.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
		return writeDouble(this, value, offset, false, noAssert);
	};
	Buffer$1.prototype.copy = function copy(target, targetStart, start, end) {
		if (!start) start = 0;
		if (!end && end !== 0) end = this.length;
		if (targetStart >= target.length) targetStart = target.length;
		if (!targetStart) targetStart = 0;
		if (end > 0 && end < start) end = start;
		if (end === start) return 0;
		if (target.length === 0 || this.length === 0) return 0;
		if (targetStart < 0) throw new RangeError("targetStart out of bounds");
		if (start < 0 || start >= this.length) throw new RangeError("sourceStart out of bounds");
		if (end < 0) throw new RangeError("sourceEnd out of bounds");
		if (end > this.length) end = this.length;
		if (target.length - targetStart < end - start) end = target.length - targetStart + start;
		var len = end - start;
		var i;
		if (this === target && start < targetStart && targetStart < end) for (i = len - 1; i >= 0; --i) target[i + targetStart] = this[i + start];
		else if (len < 1e3 || !Buffer$1.TYPED_ARRAY_SUPPORT) for (i = 0; i < len; ++i) target[i + targetStart] = this[i + start];
		else Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);
		return len;
	};
	Buffer$1.prototype.fill = function fill(val, start, end, encoding) {
		if (typeof val === "string") {
			if (typeof start === "string") {
				encoding = start;
				start = 0;
				end = this.length;
			} else if (typeof end === "string") {
				encoding = end;
				end = this.length;
			}
			if (val.length === 1) {
				var code = val.charCodeAt(0);
				if (code < 256) val = code;
			}
			if (encoding !== void 0 && typeof encoding !== "string") throw new TypeError("encoding must be a string");
			if (typeof encoding === "string" && !Buffer$1.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
		} else if (typeof val === "number") val = val & 255;
		if (start < 0 || this.length < start || this.length < end) throw new RangeError("Out of range index");
		if (end <= start) return this;
		start = start >>> 0;
		end = end === void 0 ? this.length : end >>> 0;
		if (!val) val = 0;
		var i;
		if (typeof val === "number") for (i = start; i < end; ++i) this[i] = val;
		else {
			var bytes = internalIsBuffer(val) ? val : utf8ToBytes(new Buffer$1(val, encoding).toString());
			var len = bytes.length;
			for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len];
		}
		return this;
	};
	INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;
}));
//#endregion
//#region node_modules/.pnpm/entities@7.0.1/node_modules/entities/dist/esm/internal/decode-shared.js
init__polyfill_node_buffer();
function decodeBase64(input) {
	const binary = typeof atob === "function" ? atob(input) : typeof Buffer$1.from === "function" ? Buffer$1.from(input, "base64").toString("binary") : new Buffer$1(input, "base64").toString("binary");
	const evenLength = binary.length & -2;
	const out = new Uint16Array(evenLength / 2);
	for (let index = 0, outIndex = 0; index < evenLength; index += 2) {
		const lo = binary.charCodeAt(index);
		const hi = binary.charCodeAt(index + 1);
		out[outIndex++] = lo | hi << 8;
	}
	return out;
}
//#endregion
//#region node_modules/.pnpm/entities@7.0.1/node_modules/entities/dist/esm/generated/decode-data-html.js
const htmlDecodeTree = /* #__PURE__ */ decodeBase64("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");
//#endregion
//#region node_modules/.pnpm/entities@7.0.1/node_modules/entities/dist/esm/internal/bin-trie-flags.js
/**
* Bit flags & masks for the binary trie encoding used for entity decoding.
*
* Bit layout (16 bits total):
* 15..14 VALUE_LENGTH   (+1 encoding; 0 => no value)
* 13     FLAG13.        If valueLength>0: semicolon required flag (implicit ';').
*                       If valueLength==0: compact run flag.
* 12..7  BRANCH_LENGTH  Branch length (0 => single branch in 6..0 if jumpOffset==char) OR run length (when compact run)
* 6..0   JUMP_TABLE     Jump offset (jump table) OR single-branch char code OR first run char
*/
var BinTrieFlags;
(function(BinTrieFlags) {
	BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
	BinTrieFlags[BinTrieFlags["FLAG13"] = 8192] = "FLAG13";
	BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
	BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
})(BinTrieFlags || (BinTrieFlags = {}));
//#endregion
//#region node_modules/.pnpm/entities@7.0.1/node_modules/entities/dist/esm/decode.js
var CharCodes;
(function(CharCodes) {
	CharCodes[CharCodes["NUM"] = 35] = "NUM";
	CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
	CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
	CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
	CharCodes[CharCodes["NINE"] = 57] = "NINE";
	CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
	CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
	CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
	CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
	CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
	CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
	CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
})(CharCodes || (CharCodes = {}));
/** Bit that needs to be set to convert an upper case ASCII character to lower case */
const TO_LOWER_BIT = 32;
function isNumber$1(code) {
	return code >= CharCodes.ZERO && code <= CharCodes.NINE;
}
function isHexadecimalCharacter(code) {
	return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F;
}
function isAsciiAlphaNumeric(code) {
	return code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z || code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z || isNumber$1(code);
}
/**
* Checks if the given character is a valid end character for an entity in an attribute.
*
* Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
* See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
*/
function isEntityInAttributeInvalidEnd(code) {
	return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);
}
var EntityDecoderState;
(function(EntityDecoderState) {
	EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
	EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
	EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
	EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
	EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
})(EntityDecoderState || (EntityDecoderState = {}));
var DecodingMode;
(function(DecodingMode) {
	/** Entities in text nodes that can end with any character. */
	DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
	/** Only allow entities terminated with a semicolon. */
	DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
	/** Entities in attributes have limitations on ending characters. */
	DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
})(DecodingMode || (DecodingMode = {}));
/**
* Token decoder with support of writing partial entities.
*/
var EntityDecoder = class {
	constructor(decodeTree, emitCodePoint, errors) {
		this.decodeTree = decodeTree;
		this.emitCodePoint = emitCodePoint;
		this.errors = errors;
		/** The current state of the decoder. */
		this.state = EntityDecoderState.EntityStart;
		/** Characters that were consumed while parsing an entity. */
		this.consumed = 1;
		/**
		* The result of the entity.
		*
		* Either the result index of a numeric entity, or the codepoint of a
		* numeric entity.
		*/
		this.result = 0;
		/** The current index in the decode tree. */
		this.treeIndex = 0;
		/** The number of characters that were consumed in excess. */
		this.excess = 1;
		/** The mode in which the decoder is operating. */
		this.decodeMode = DecodingMode.Strict;
		/** The number of characters that have been consumed in the current run. */
		this.runConsumed = 0;
	}
	/** Resets the instance to make it reusable. */
	startEntity(decodeMode) {
		this.decodeMode = decodeMode;
		this.state = EntityDecoderState.EntityStart;
		this.result = 0;
		this.treeIndex = 0;
		this.excess = 1;
		this.consumed = 1;
		this.runConsumed = 0;
	}
	/**
	* Write an entity to the decoder. This can be called multiple times with partial entities.
	* If the entity is incomplete, the decoder will return -1.
	*
	* Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
	* entity is incomplete, and resume when the next string is written.
	*
	* @param input The string containing the entity (or a continuation of the entity).
	* @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
	*/
	write(input, offset) {
		switch (this.state) {
			case EntityDecoderState.EntityStart:
				if (input.charCodeAt(offset) === CharCodes.NUM) {
					this.state = EntityDecoderState.NumericStart;
					this.consumed += 1;
					return this.stateNumericStart(input, offset + 1);
				}
				this.state = EntityDecoderState.NamedEntity;
				return this.stateNamedEntity(input, offset);
			case EntityDecoderState.NumericStart: return this.stateNumericStart(input, offset);
			case EntityDecoderState.NumericDecimal: return this.stateNumericDecimal(input, offset);
			case EntityDecoderState.NumericHex: return this.stateNumericHex(input, offset);
			case EntityDecoderState.NamedEntity: return this.stateNamedEntity(input, offset);
		}
	}
	/**
	* Switches between the numeric decimal and hexadecimal states.
	*
	* Equivalent to the `Numeric character reference state` in the HTML spec.
	*
	* @param input The string containing the entity (or a continuation of the entity).
	* @param offset The current offset.
	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
	*/
	stateNumericStart(input, offset) {
		if (offset >= input.length) return -1;
		if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
			this.state = EntityDecoderState.NumericHex;
			this.consumed += 1;
			return this.stateNumericHex(input, offset + 1);
		}
		this.state = EntityDecoderState.NumericDecimal;
		return this.stateNumericDecimal(input, offset);
	}
	/**
	* Parses a hexadecimal numeric entity.
	*
	* Equivalent to the `Hexademical character reference state` in the HTML spec.
	*
	* @param input The string containing the entity (or a continuation of the entity).
	* @param offset The current offset.
	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
	*/
	stateNumericHex(input, offset) {
		while (offset < input.length) {
			const char = input.charCodeAt(offset);
			if (isNumber$1(char) || isHexadecimalCharacter(char)) {
				const digit = char <= CharCodes.NINE ? char - CharCodes.ZERO : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;
				this.result = this.result * 16 + digit;
				this.consumed++;
				offset++;
			} else return this.emitNumericEntity(char, 3);
		}
		return -1;
	}
	/**
	* Parses a decimal numeric entity.
	*
	* Equivalent to the `Decimal character reference state` in the HTML spec.
	*
	* @param input The string containing the entity (or a continuation of the entity).
	* @param offset The current offset.
	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
	*/
	stateNumericDecimal(input, offset) {
		while (offset < input.length) {
			const char = input.charCodeAt(offset);
			if (isNumber$1(char)) {
				this.result = this.result * 10 + (char - CharCodes.ZERO);
				this.consumed++;
				offset++;
			} else return this.emitNumericEntity(char, 2);
		}
		return -1;
	}
	/**
	* Validate and emit a numeric entity.
	*
	* Implements the logic from the `Hexademical character reference start
	* state` and `Numeric character reference end state` in the HTML spec.
	*
	* @param lastCp The last code point of the entity. Used to see if the
	*               entity was terminated with a semicolon.
	* @param expectedLength The minimum number of characters that should be
	*                       consumed. Used to validate that at least one digit
	*                       was consumed.
	* @returns The number of characters that were consumed.
	*/
	emitNumericEntity(lastCp, expectedLength) {
		var _a;
		if (this.consumed <= expectedLength) {
			(_a = this.errors) === null || _a === void 0 || _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
			return 0;
		}
		if (lastCp === CharCodes.SEMI) this.consumed += 1;
		else if (this.decodeMode === DecodingMode.Strict) return 0;
		this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
		if (this.errors) {
			if (lastCp !== CharCodes.SEMI) this.errors.missingSemicolonAfterCharacterReference();
			this.errors.validateNumericCharacterReference(this.result);
		}
		return this.consumed;
	}
	/**
	* Parses a named entity.
	*
	* Equivalent to the `Named character reference state` in the HTML spec.
	*
	* @param input The string containing the entity (or a continuation of the entity).
	* @param offset The current offset.
	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
	*/
	stateNamedEntity(input, offset) {
		const { decodeTree } = this;
		let current = decodeTree[this.treeIndex];
		let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
		while (offset < input.length) {
			if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {
				const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
				if (this.runConsumed === 0) {
					const firstChar = current & BinTrieFlags.JUMP_TABLE;
					if (input.charCodeAt(offset) !== firstChar) return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
					offset++;
					this.excess++;
					this.runConsumed++;
				}
				while (this.runConsumed < runLength) {
					if (offset >= input.length) return -1;
					const charIndexInPacked = this.runConsumed - 1;
					const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
					const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
					if (input.charCodeAt(offset) !== expectedChar) {
						this.runConsumed = 0;
						return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
					}
					offset++;
					this.excess++;
					this.runConsumed++;
				}
				this.runConsumed = 0;
				this.treeIndex += 1 + (runLength >> 1);
				current = decodeTree[this.treeIndex];
				valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
			}
			if (offset >= input.length) break;
			const char = input.charCodeAt(offset);
			if (char === CharCodes.SEMI && valueLength !== 0 && (current & BinTrieFlags.FLAG13) !== 0) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
			this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
			if (this.treeIndex < 0) return this.result === 0 || this.decodeMode === DecodingMode.Attribute && (valueLength === 0 || isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
			current = decodeTree[this.treeIndex];
			valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
			if (valueLength !== 0) {
				if (char === CharCodes.SEMI) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
				if (this.decodeMode !== DecodingMode.Strict && (current & BinTrieFlags.FLAG13) === 0) {
					this.result = this.treeIndex;
					this.consumed += this.excess;
					this.excess = 0;
				}
			}
			offset++;
			this.excess++;
		}
		return -1;
	}
	/**
	* Emit a named entity that was not terminated with a semicolon.
	*
	* @returns The number of characters consumed.
	*/
	emitNotTerminatedNamedEntity() {
		var _a;
		const { result, decodeTree } = this;
		const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
		this.emitNamedEntityData(result, valueLength, this.consumed);
		(_a = this.errors) === null || _a === void 0 || _a.missingSemicolonAfterCharacterReference();
		return this.consumed;
	}
	/**
	* Emit a named entity.
	*
	* @param result The index of the entity in the decode tree.
	* @param valueLength The number of bytes in the entity.
	* @param consumed The number of characters consumed.
	*
	* @returns The number of characters consumed.
	*/
	emitNamedEntityData(result, valueLength, consumed) {
		const { decodeTree } = this;
		this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~(BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13) : decodeTree[result + 1], consumed);
		if (valueLength === 3) this.emitCodePoint(decodeTree[result + 2], consumed);
		return consumed;
	}
	/**
	* Signal to the parser that the end of the input was reached.
	*
	* Remaining data will be emitted and relevant errors will be produced.
	*
	* @returns The number of characters consumed.
	*/
	end() {
		var _a;
		switch (this.state) {
			case EntityDecoderState.NamedEntity: return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
			case EntityDecoderState.NumericDecimal: return this.emitNumericEntity(0, 2);
			case EntityDecoderState.NumericHex: return this.emitNumericEntity(0, 3);
			case EntityDecoderState.NumericStart:
				(_a = this.errors) === null || _a === void 0 || _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
				return 0;
			case EntityDecoderState.EntityStart: return 0;
		}
	}
};
/**
* Creates a function that decodes entities in a string.
*
* @param decodeTree The decode tree.
* @returns A function that decodes entities in a string.
*/
function getDecoder(decodeTree) {
	let returnValue = "";
	const decoder = new EntityDecoder(decodeTree, (data) => returnValue += fromCodePoint(data));
	return function decodeWithTrie(input, decodeMode) {
		let lastIndex = 0;
		let offset = 0;
		while ((offset = input.indexOf("&", offset)) >= 0) {
			returnValue += input.slice(lastIndex, offset);
			decoder.startEntity(decodeMode);
			const length = decoder.write(input, offset + 1);
			if (length < 0) {
				lastIndex = offset + decoder.end();
				break;
			}
			lastIndex = offset + length;
			offset = length === 0 ? lastIndex + 1 : lastIndex;
		}
		const result = returnValue + input.slice(lastIndex);
		returnValue = "";
		return result;
	};
}
/**
* Determines the branch of the current node that is taken given the current
* character. This function is used to traverse the trie.
*
* @param decodeTree The trie.
* @param current The current node.
* @param nodeIdx The index right after the current node and its value.
* @param char The current character.
* @returns The index of the next node, or -1 if no branch is taken.
*/
function determineBranch(decodeTree, current, nodeIndex, char) {
	const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
	const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
	if (branchCount === 0) return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
	if (jumpOffset) {
		const value = char - jumpOffset;
		return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIndex + value] - 1;
	}
	const packedKeySlots = branchCount + 1 >> 1;
	let lo = 0;
	let hi = branchCount - 1;
	while (lo <= hi) {
		const mid = lo + hi >>> 1;
		const midKey = decodeTree[nodeIndex + (mid >> 1)] >> (mid & 1) * 8 & 255;
		if (midKey < char) lo = mid + 1;
		else if (midKey > char) hi = mid - 1;
		else return decodeTree[nodeIndex + packedKeySlots + mid];
	}
	return -1;
}
const htmlDecoder = /* #__PURE__ */ getDecoder(htmlDecodeTree);
/**
* Decodes an HTML string.
*
* @param htmlString The string to decode.
* @param mode The decoding mode.
* @returns The decoded string.
*/
function decodeHTML(htmlString, mode = DecodingMode.Legacy) {
	return htmlDecoder(htmlString, mode);
}
//#endregion
//#region packages/compiler-core/src/tokenizer.ts
/**
* Note: entities is a non-browser-build-only dependency.
* In the browser, we use an HTML element to do the decoding.
* Make sure all imports from entities are only used in non-browser branches
* so that it can be properly treeshaken.
*/
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$1(c) {
	return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
}
function isEndOfTagSection(c) {
	return c === 47 || c === 62 || isWhitespace$1(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;
		this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));
	}
	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 (c === 38) this.startEntity();
		else if (!this.inVPre && c === this.delimiterOpen[0]) {
			this.state = 2;
			this.delimiterIndex = 0;
			this.stateInterpolationOpen(c);
		}
	}
	stateInterpolationOpen(c) {
		if (c === this.delimiterOpen[this.delimiterIndex]) {
			if (this.delimiterIndex === this.delimiterOpen.length - 1) {
				const start = this.index + 1 - this.delimiterOpen.length;
				if (start > this.sectionStart) this.cbs.ontext(this.sectionStart, start);
				this.state = 3;
				this.sectionStart = start;
			} else this.delimiterIndex++;
		} else if (this.inRCDATA) {
			this.state = 32;
			this.stateInRCDATA(c);
		} else {
			this.state = 1;
			this.stateText(c);
		}
	}
	stateInterpolation(c) {
		if (c === this.delimiterClose[0]) {
			this.state = 4;
			this.delimiterIndex = 0;
			this.stateInterpolationClose(c);
		}
	}
	stateInterpolationClose(c) {
		if (c === this.delimiterClose[this.delimiterIndex]) {
			if (this.delimiterIndex === this.delimiterClose.length - 1) {
				this.cbs.oninterpolation(this.sectionStart, this.index + 1);
				if (this.inRCDATA) this.state = 32;
				else this.state = 1;
				this.sectionStart = this.index + 1;
			} else this.delimiterIndex++;
		} else {
			this.state = 3;
			this.stateInterpolation(c);
		}
	}
	stateSpecialStartSequence(c) {
		const isEnd = this.sequenceIndex === this.currentSequence.length;
		if (!(isEnd ? isEndOfTagSection(c) : (c | 32) === this.currentSequence[this.sequenceIndex])) this.inRCDATA = false;
		else if (!isEnd) {
			this.sequenceIndex++;
			return;
		}
		this.sequenceIndex = 0;
		this.state = 6;
		this.stateInTagName(c);
	}
	/** Look for an end tag. For <title> and <textarea>, also decode entities. */
	stateInRCDATA(c) {
		if (this.sequenceIndex === this.currentSequence.length) {
			if (c === 62 || isWhitespace$1(c)) {
				const endOfText = this.index - this.currentSequence.length;
				if (this.sectionStart < endOfText) {
					const actualIndex = this.index;
					this.index = endOfText;
					this.cbs.ontext(this.sectionStart, endOfText);
					this.index = actualIndex;
				}
				this.sectionStart = endOfText + 2;
				this.stateInClosingTagName(c);
				this.inRCDATA = false;
				return;
			}
			this.sequenceIndex = 0;
		}
		if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;
		else if (this.sequenceIndex === 0) {
			if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
				if (c === 38) this.startEntity();
				else if (!this.inVPre && c === this.delimiterOpen[0]) {
					this.state = 2;
					this.delimiterIndex = 0;
					this.stateInterpolationOpen(c);
				}
			} else if (this.fastForwardTo(60)) this.sequenceIndex = 1;
		} else this.sequenceIndex = Number(c === 60);
	}
	stateCDATASequence(c) {
		if (c === Sequences.Cdata[this.sequenceIndex]) {
			if (++this.sequenceIndex === Sequences.Cdata.length) {
				this.state = 28;
				this.currentSequence = Sequences.CdataEnd;
				this.sequenceIndex = 0;
				this.sectionStart = this.index + 1;
			}
		} else {
			this.sequenceIndex = 0;
			this.state = 23;
			this.stateInDeclaration(c);
		}
	}
	/**
	* When we wait for one specific character, we can speed things up
	* by skipping through the buffer until we find it.
	*
	* @returns Whether the character was found.
	*/
	fastForwardTo(c) {
		while (++this.index < this.buffer.length) {
			const cc = this.buffer.charCodeAt(this.index);
			if (cc === 10) this.newlines.push(this.index);
			if (cc === c) return true;
		}
		this.index = this.buffer.length - 1;
		return false;
	}
	/**
	* Comments and CDATA end with `-->` and `]]>`.
	*
	* Their common qualities are:
	* - Their end sequences have a distinct character they start with.
	* - That character is then repeated, so we have to check multiple repeats.
	* - All characters but the start character of the sequence can be skipped.
	*/
	stateInCommentLike(c) {
		if (c === this.currentSequence[this.sequenceIndex]) {
			if (++this.sequenceIndex === this.currentSequence.length) {
				if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, this.index - 2);
				else this.cbs.oncomment(this.sectionStart, this.index - 2);
				this.sequenceIndex = 0;
				this.sectionStart = this.index + 1;
				this.state = 1;
			}
		} else if (this.sequenceIndex === 0) {
			if (this.fastForwardTo(this.currentSequence[0])) this.sequenceIndex = 1;
		} else if (c !== this.currentSequence[this.sequenceIndex - 1]) this.sequenceIndex = 0;
	}
	startSpecial(sequence, offset) {
		this.enterRCDATA(sequence, offset);
		this.state = 31;
	}
	enterRCDATA(sequence, offset) {
		this.inRCDATA = true;
		this.currentSequence = sequence;
		this.sequenceIndex = offset;
	}
	stateBeforeTagName(c) {
		if (c === 33) {
			this.state = 22;
			this.sectionStart = this.index + 1;
		} else if (c === 63) {
			this.state = 24;
			this.sectionStart = this.index + 1;
		} else if (isTagStartChar(c)) {
			this.sectionStart = this.index;
			if (this.mode === 0) this.state = 6;
			else if (this.inSFCRoot) this.state = 34;
			else if (!this.inXML) {
				if (c === 116) this.state = 30;
				else this.state = c === 115 ? 29 : 6;
			} else this.state = 6;
		} else if (c === 47) this.state = 8;
		else {
			this.state = 1;
			this.stateText(c);
		}
	}
	stateInTagName(c) {
		if (isEndOfTagSection(c)) this.handleTagName(c);
	}
	stateInSFCRootTagName(c) {
		if (isEndOfTagSection(c)) {
			const tag = this.buffer.slice(this.sectionStart, this.index);
			if (tag !== "template") this.enterRCDATA(toCharCodes(`</` + tag), 0);
			this.handleTagName(c);
		}
	}
	handleTagName(c) {
		this.cbs.onopentagname(this.sectionStart, this.index);
		this.sectionStart = -1;
		this.state = 11;
		this.stateBeforeAttrName(c);
	}
	stateBeforeClosingTagName(c) {
		if (isWhitespace$1(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$1(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$1(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$1(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$1(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$1(c)) {
			this.sectionStart = this.index;
			this.state = 21;
			this.stateInAttrValueNoQuotes(c);
		}
	}
	handleInAttrValue(c, quote) {
		if (c === quote || false) {
			this.cbs.onattribdata(this.sectionStart, this.index);
			this.sectionStart = -1;
			this.cbs.onattribend(quote === 34 ? 3 : 2, this.index + 1);
			this.state = 11;
		} else if (c === 38) this.startEntity();
	}
	stateInAttrValueDoubleQuotes(c) {
		this.handleInAttrValue(c, 34);
	}
	stateInAttrValueSingleQuotes(c) {
		this.handleInAttrValue(c, 39);
	}
	stateInAttrValueNoQuotes(c) {
		if (isWhitespace$1(c) || c === 62) {
			this.cbs.onattribdata(this.sectionStart, this.index);
			this.sectionStart = -1;
			this.cbs.onattribend(1, this.index);
			this.state = 11;
			this.stateBeforeAttrName(c);
		} else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) this.cbs.onerr(18, this.index);
		else if (c === 38) this.startEntity();
	}
	stateBeforeDeclaration(c) {
		if (c === 91) {
			this.state = 26;
			this.sequenceIndex = 0;
		} else this.state = c === 45 ? 25 : 23;
	}
	stateInDeclaration(c) {
		if (c === 62 || this.fastForwardTo(62)) {
			this.state = 1;
			this.sectionStart = this.index + 1;
		}
	}
	stateInProcessingInstruction(c) {
		if (c === 62 || this.fastForwardTo(62)) {
			this.cbs.onprocessinginstruction(this.sectionStart, this.index);
			this.state = 1;
			this.sectionStart = this.index + 1;
		}
	}
	stateBeforeComment(c) {
		if (c === 45) {
			this.state = 28;
			this.currentSequence = Sequences.CommentEnd;
			this.sequenceIndex = 2;
			this.sectionStart = this.index + 1;
		} else this.state = 23;
	}
	stateInSpecialComment(c) {
		if (c === 62 || this.fastForwardTo(62)) {
			this.cbs.oncomment(this.sectionStart, this.index);
			this.state = 1;
			this.sectionStart = this.index + 1;
		}
	}
	stateBeforeSpecialS(c) {
		if (c === Sequences.ScriptEnd[3]) this.startSpecial(Sequences.ScriptEnd, 4);
		else if (c === Sequences.StyleEnd[3]) this.startSpecial(Sequences.StyleEnd, 4);
		else {
			this.state = 6;
			this.stateInTagName(c);
		}
	}
	stateBeforeSpecialT(c) {
		if (c === Sequences.TitleEnd[3]) this.startSpecial(Sequences.TitleEnd, 4);
		else if (c === Sequences.TextareaEnd[3]) this.startSpecial(Sequences.TextareaEnd, 4);
		else {
			this.state = 6;
			this.stateInTagName(c);
		}
	}
	startEntity() {
		this.baseState = this.state;
		this.state = 33;
		this.entityStart = this.index;
		this.entityDecoder.startEntity(this.baseState === 1 || this.baseState === 32 ? DecodingMode.Legacy : DecodingMode.Attribute);
	}
	stateInEntity() {
		{
			const length = this.entityDecoder.write(this.buffer, this.index);
			if (length >= 0) {
				this.state = this.baseState;
				if (length === 0) this.index = this.entityStart;
			} else this.index = this.buffer.length - 1;
		}
	}
	/**
	* Iterates through the buffer, calling the function corresponding to the current state.
	*
	* States that are more likely to be hit are higher up, as a performance improvement.
	*/
	parse(input) {
		this.buffer = input;
		while (this.index < this.buffer.length) {
			const c = this.buffer.charCodeAt(this.index);
			if (c === 10 && this.state !== 33) this.newlines.push(this.index);
			switch (this.state) {
				case 1:
					this.stateText(c);
					break;
				case 2:
					this.stateInterpolationOpen(c);
					break;
				case 3:
					this.stateInterpolation(c);
					break;
				case 4:
					this.stateInterpolationClose(c);
					break;
				case 31:
					this.stateSpecialStartSequence(c);
					break;
				case 32:
					this.stateInRCDATA(c);
					break;
				case 26:
					this.stateCDATASequence(c);
					break;
				case 19:
					this.stateInAttrValueDoubleQuotes(c);
					break;
				case 12:
					this.stateInAttrName(c);
					break;
				case 13:
					this.stateInDirName(c);
					break;
				case 14:
					this.stateInDirArg(c);
					break;
				case 15:
					this.stateInDynamicDirArg(c);
					break;
				case 16:
					this.stateInDirModifier(c);
					break;
				case 28:
					this.stateInCommentLike(c);
					break;
				case 27:
					this.stateInSpecialComment(c);
					break;
				case 11:
					this.stateBeforeAttrName(c);
					break;
				case 6:
					this.stateInTagName(c);
					break;
				case 34:
					this.stateInSFCRootTagName(c);
					break;
				case 9:
					this.stateInClosingTagName(c);
					break;
				case 5:
					this.stateBeforeTagName(c);
					break;
				case 17:
					this.stateAfterAttrName(c);
					break;
				case 20:
					this.stateInAttrValueSingleQuotes(c);
					break;
				case 18:
					this.stateBeforeAttrValue(c);
					break;
				case 8:
					this.stateBeforeClosingTagName(c);
					break;
				case 10:
					this.stateAfterClosingTagName(c);
					break;
				case 29:
					this.stateBeforeSpecialS(c);
					break;
				case 30:
					this.stateBeforeSpecialT(c);
					break;
				case 21:
					this.stateInAttrValueNoQuotes(c);
					break;
				case 7:
					this.stateInSelfClosingTag(c);
					break;
				case 23:
					this.stateInDeclaration(c);
					break;
				case 22:
					this.stateBeforeDeclaration(c);
					break;
				case 25:
					this.stateBeforeComment(c);
					break;
				case 24:
					this.stateInProcessingInstruction(c);
					break;
				case 33: this.stateInEntity();
			}
			this.index++;
		}
		this.cleanup();
		this.finish();
	}
	/**
	* Remove data that has already been consumed from the buffer.
	*/
	cleanup() {
		if (this.sectionStart !== this.index) {
			if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
				this.cbs.ontext(this.sectionStart, this.index);
				this.sectionStart = this.index;
			} else if (this.state === 19 || this.state === 20 || this.state === 21) {
				this.cbs.onattribdata(this.sectionStart, this.index);
				this.sectionStart = this.index;
			}
		}
	}
	finish() {
		if (this.state === 33) {
			this.entityDecoder.end();
			this.state = this.baseState;
		}
		this.handleTrailingData();
		this.cbs.onend();
	}
	/** Handle any trailing data. */
	handleTrailingData() {
		const endIndex = this.buffer.length;
		if (this.sectionStart >= endIndex) return;
		if (this.state === 28) {
			if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, endIndex);
			else this.cbs.oncomment(this.sectionStart, endIndex);
		} else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) {} else this.cbs.ontext(this.sectionStart, endIndex);
	}
	emitCodePoint(cp, consumed) {
		if (this.baseState !== 1 && this.baseState !== 32) {
			if (this.sectionStart < this.entityStart) this.cbs.onattribdata(this.sectionStart, this.entityStart);
			this.sectionStart = this.entityStart + consumed;
			this.index = this.sectionStart - 1;
			this.cbs.onattribentity(fromCodePoint(cp), this.entityStart, this.sectionStart);
		} else {
			if (this.sectionStart < this.entityStart) this.cbs.ontext(this.sectionStart, this.entityStart);
			this.sectionStart = this.entityStart + consumed;
			this.index = this.sectionStart - 1;
			this.cbs.ontextentity(fromCodePoint(cp), this.entityStart, this.sectionStart);
		}
	}
};
//#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$1)[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$1 = {
	[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 node_modules/.pnpm/@babel+parser@7.29.8/node_modules/@babel/parser/lib/index.js
var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	function _objectWithoutPropertiesLoose(r, e) {
		if (null == r) return {};
		var t = {};
		for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
			if (-1 !== e.indexOf(n)) continue;
			t[n] = r[n];
		}
		return t;
	}
	var Position = class {
		constructor(line, col, index) {
			this.line = void 0;
			this.column = void 0;
			this.index = void 0;
			this.line = line;
			this.column = col;
			this.index = index;
		}
	};
	var SourceLocation = class {
		constructor(start, end) {
			this.start = void 0;
			this.end = void 0;
			this.filename = void 0;
			this.identifierName = void 0;
			this.start = start;
			this.end = end;
		}
	};
	function createPositionWithColumnOffset(position, columnOffset) {
		const { line, column, index } = position;
		return new Position(line, column + columnOffset, index + columnOffset);
	}
	const code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
	var ModuleErrors = {
		ImportMetaOutsideModule: {
			message: `import.meta may appear only with 'sourceType: "module"'`,
			code
		},
		ImportOutsideModule: {
			message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
			code
		}
	};
	const NodeDescriptions = {
		ArrayPattern: "array destructuring pattern",
		AssignmentExpression: "assignment expression",
		AssignmentPattern: "assignment expression",
		ArrowFunctionExpression: "arrow function expression",
		ConditionalExpression: "conditional expression",
		CatchClause: "catch clause",
		ForOfStatement: "for-of statement",
		ForInStatement: "for-in statement",
		ForStatement: "for-loop",
		FormalParameters: "function parameter list",
		Identifier: "identifier",
		ImportSpecifier: "import specifier",
		ImportDefaultSpecifier: "import default specifier",
		ImportNamespaceSpecifier: "import namespace specifier",
		ObjectPattern: "object destructuring pattern",
		ParenthesizedExpression: "parenthesized expression",
		RestElement: "rest element",
		UpdateExpression: {
			true: "prefix operation",
			false: "postfix operation"
		},
		VariableDeclarator: "variable declaration",
		YieldExpression: "yield expression"
	};
	const toNodeDescription = (node) => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
	var StandardErrors = {
		AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`,
		ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
		AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
		AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
		AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
		AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
		AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
		AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
		BadGetterArity: "A 'get' accessor must not have any formal parameters.",
		BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
		BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
		ConstructorClassField: "Classes may not have a field named 'constructor'.",
		ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
		ConstructorIsAccessor: "Class constructor may not be an accessor.",
		ConstructorIsAsync: "Constructor can't be an async function.",
		ConstructorIsGenerator: "Constructor can't be a generator.",
		DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
		DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
		DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
		DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
		DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
		DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
		DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
		DecoratorStaticBlock: "Decorators can't be used with a static block.",
		DeferImportRequiresNamespace: "Only `import defer * as x from \"./module\"` is valid.",
		DeletePrivateField: "Deleting a private field is not allowed.",
		DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
		DuplicateConstructor: "Duplicate constructor in the same class.",
		DuplicateDefaultExport: "Only one default export allowed per module.",
		DuplicateExport: ({ exportName }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
		DuplicateProto: "Redefinition of __proto__ property.",
		DuplicateRegExpFlags: "Duplicate regular expression flag.",
		ElementAfterRest: "Rest element must be last element.",
		EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
		ExportBindingIsString: ({ localName, exportName }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
		ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
		ForInOfLoopInitializer: ({ type }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
		ForInUsing: "For-in loop may not start with 'using' declaration.",
		ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
		ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
		GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
		IllegalBreakContinue: ({ type }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
		IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
		IllegalReturn: "'return' outside of function.",
		ImportAttributesUseAssert: "The `assert` keyword in import attributes is deprecated and it has been replaced by the `with` keyword. You can enable the `deprecatedImportAssert` parser plugin to suppress this error.",
		ImportBindingIsString: ({ importName }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
		ImportCallArity: `\`import()\` requires exactly one or two arguments.`,
		ImportCallNotNewExpression: "Cannot use new with import(...).",
		ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
		ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
		ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
		ImportReflectionNotBinding: "Only `import module x from \"./module\"` is valid.",
		IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
		InvalidBigIntLiteral: "Invalid BigIntLiteral.",
		InvalidCodePoint: "Code point out of bounds.",
		InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.",
		InvalidCoverInitializedName: "Invalid shorthand property initializer.",
		InvalidDecimal: "Invalid decimal.",
		InvalidDigit: ({ radix }) => `Expected number in radix ${radix}.`,
		InvalidEscapeSequence: "Bad character escape sequence.",
		InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
		InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
		InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`,
		InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
		InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
		InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
		InvalidNumber: "Invalid number.",
		InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
		InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`,
		InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
		InvalidPrivateFieldResolution: ({ identifierName }) => `Private name #${identifierName} is not defined.`,
		InvalidPropertyBindingPattern: "Binding member expression.",
		InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.",
		InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
		LabelRedeclaration: ({ labelName }) => `Label '${labelName}' is already declared.`,
		LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
		LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
		MalformedRegExpFlags: "Invalid regular expression flag.",
		MissingClassName: "A class name is required.",
		MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
		MissingSemicolon: "Missing semicolon.",
		MissingPlugin: ({ missingPlugin }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
		MissingOneOfPlugins: ({ missingPlugin }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
		MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
		MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
		ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.",
		ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
		ModuleAttributesWithDuplicateKeys: ({ key }) => `Duplicate key "${key}" is not allowed in module attributes.`,
		ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
		ModuleExportUndefined: ({ localName }) => `Export '${localName}' is not defined.`,
		MultipleDefaultsInSwitch: "Multiple default clauses.",
		NewlineAfterThrow: "Illegal newline after throw.",
		NoCatchOrFinally: "Missing catch or finally clause.",
		NumberIdentifier: "Identifier directly after number.",
		NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
		ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
		OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
		OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
		OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
		ParamDupe: "Argument name clash.",
		PatternHasAccessor: "Object pattern can't contain getter or setter.",
		PatternHasMethod: "Object pattern can't contain methods.",
		PrivateInExpectedIn: ({ identifierName }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
		PrivateNameRedeclaration: ({ identifierName }) => `Duplicate private name #${identifierName}.`,
		RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
		RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
		RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
		RecordNoProto: "'__proto__' is not allowed in Record expressions.",
		RestTrailingComma: "Unexpected trailing comma after rest element.",
		SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
		SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
		SourcePhaseImportRequiresDefault: "Only `import source x from \"./module\"` is valid.",
		StaticPrototype: "Classes may not have static property named prototype.",
		SuperCallNotNewExpression: "Cannot use new with super(...).",
		SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
		SuperPrivateField: "Private fields can't be accessed on super.",
		TrailingDecorator: "Decorators must be attached to a class element.",
		TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
		TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
		TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
		UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
		UnexpectedAwaitAfterPipelineBody: "Unexpected \"await\" after pipeline body; await must have parentheses in minimal proposal.",
		UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
		UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
		UnexpectedKeyword: ({ keyword }) => `Unexpected keyword '${keyword}'.`,
		UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
		UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
		UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
		UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
		UnexpectedPrivateField: "Unexpected private name.",
		UnexpectedReservedWord: ({ reservedWord }) => `Unexpected reserved word '${reservedWord}'.`,
		UnexpectedSuper: "'super' is only allowed in object methods and classes.",
		UnexpectedToken: ({ expected, unexpected }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
		UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
		UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
		UnexpectedVoidPattern: "Unexpected void binding.",
		UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
		UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
		UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
		UnsupportedMetaProperty: ({ target, onlyValidPropertyName }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
		UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
		UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
		UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
		UnterminatedComment: "Unterminated comment.",
		UnterminatedRegExp: "Unterminated regular expression.",
		UnterminatedString: "Unterminated string constant.",
		UnterminatedTemplate: "Unterminated template.",
		UsingDeclarationExport: "Using declaration cannot be exported.",
		UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
		VarRedeclaration: ({ identifierName }) => `Identifier '${identifierName}' has already been declared.`,
		VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.",
		VoidPatternInitializer: "A void binding may not have an initializer.",
		YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
		YieldInParameter: "Yield expression is not allowed in formal parameters.",
		YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
		ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
	};
	var StrictModeErrors = {
		StrictDelete: "Deleting local variable in strict mode.",
		StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`,
		StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`,
		StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
		StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
		StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
		StrictWith: "'with' in strict mode."
	};
	var ParseExpressionErrors = {
		ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
		ParseExpressionExpectsEOF: ({ unexpected }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
	};
	const UnparenthesizedPipeBodyDescriptions = /* @__PURE__ */ new Set([
		"ArrowFunctionExpression",
		"AssignmentExpression",
		"ConditionalExpression",
		"YieldExpression"
	]);
	var PipelineOperatorErrors = Object.assign({
		PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
		PipeTopicRequiresHackPipes: "Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option.",
		PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
		PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
		PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
		PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`
	}, {
		PipelineBodyNoArrow: "Unexpected arrow \"=>\" after pipeline body; arrow function in pipeline body must be parenthesized.",
		PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
		PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
		PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
		PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
		PrimaryTopicRequiresSmartPipeline: "Topic reference is used, but the pipelineOperator plugin was not passed a \"proposal\": \"hack\" or \"smart\" option."
	});
	var FunctionBindErrors = {
		UnsupportedBind: "Binding should be performed on object property.",
		UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
	};
	const _excluded = ["message"];
	function defineHidden(obj, key, value) {
		Object.defineProperty(obj, key, {
			enumerable: false,
			configurable: true,
			value
		});
	}
	function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
		const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
		const oldReasonCodes = {
			AccessorCannotDeclareThisParameter: "AccesorCannotDeclareThisParameter",
			AccessorCannotHaveTypeParameters: "AccesorCannotHaveTypeParameters",
			ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference",
			SetAccessorCannotHaveOptionalParameter: "SetAccesorCannotHaveOptionalParameter",
			SetAccessorCannotHaveRestParameter: "SetAccesorCannotHaveRestParameter",
			SetAccessorCannotHaveReturnType: "SetAccesorCannotHaveReturnType"
		};
		if (oldReasonCodes[reasonCode]) reasonCode = oldReasonCodes[reasonCode];
		return function constructor(loc, details) {
			const error = /* @__PURE__ */ new SyntaxError();
			error.code = code;
			error.reasonCode = reasonCode;
			error.loc = loc;
			error.pos = loc.index;
			error.syntaxPlugin = syntaxPlugin;
			if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
			defineHidden(error, "clone", function clone(overrides = {}) {
				var _overrides$loc;
				const { line, column, index } = (_overrides$loc = overrides.loc) != null ? _overrides$loc : loc;
				return constructor(new Position(line, column, index), Object.assign({}, details, overrides.details));
			});
			defineHidden(error, "details", details);
			Object.defineProperty(error, "message", {
				configurable: true,
				get() {
					const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
					this.message = message;
					return message;
				},
				set(value) {
					Object.defineProperty(this, "message", {
						value,
						writable: true
					});
				}
			});
			return error;
		};
	}
	function ParseErrorEnum(argument, syntaxPlugin) {
		if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
		const ParseErrorConstructors = {};
		for (const reasonCode of Object.keys(argument)) {
			const template = argument[reasonCode];
			const _ref = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template, { message } = _ref, rest = _objectWithoutPropertiesLoose(_ref, _excluded);
			ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
				code: "BABEL_PARSER_SYNTAX_ERROR",
				reasonCode,
				toMessage: typeof message === "string" ? () => message : message
			}, syntaxPlugin ? { syntaxPlugin } : {}, rest));
		}
		return ParseErrorConstructors;
	}
	const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum(ParseExpressionErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors), ParseErrorEnum`functionBind`(FunctionBindErrors));
	function createDefaultOptions() {
		return {
			sourceType: "script",
			sourceFilename: void 0,
			startIndex: 0,
			startColumn: 0,
			startLine: 1,
			allowAwaitOutsideFunction: false,
			allowReturnOutsideFunction: false,
			allowNewTargetOutsideFunction: false,
			allowImportExportEverywhere: false,
			allowSuperOutsideMethod: false,
			allowUndeclaredExports: false,
			allowYieldOutsideFunction: false,
			plugins: [],
			strictMode: void 0,
			ranges: false,
			tokens: false,
			createImportExpressions: false,
			createParenthesizedExpressions: false,
			errorRecovery: false,
			attachComment: true,
			annexB: true
		};
	}
	function getOptions(opts) {
		const options = createDefaultOptions();
		if (opts == null) return options;
		if (opts.annexB != null && opts.annexB !== false) throw new Error("The `annexB` option can only be set to `false`.");
		for (const key of Object.keys(options)) if (opts[key] != null) options[key] = opts[key];
		if (options.startLine === 1) {
			if (opts.startIndex == null && options.startColumn > 0) options.startIndex = options.startColumn;
			else if (opts.startColumn == null && options.startIndex > 0) options.startColumn = options.startIndex;
		} else if (opts.startColumn == null || opts.startIndex == null) {
			if (opts.startIndex != null) throw new Error("With a `startLine > 1` you must also specify `startIndex` and `startColumn`.");
		}
		if (options.sourceType === "commonjs") {
			if (opts.allowAwaitOutsideFunction != null) throw new Error("The `allowAwaitOutsideFunction` option cannot be used with `sourceType: 'commonjs'`.");
			if (opts.allowReturnOutsideFunction != null) throw new Error("`sourceType: 'commonjs'` implies `allowReturnOutsideFunction: true`, please remove the `allowReturnOutsideFunction` option or use `sourceType: 'script'`.");
			if (opts.allowNewTargetOutsideFunction != null) throw new Error("`sourceType: 'commonjs'` implies `allowNewTargetOutsideFunction: true`, please remove the `allowNewTargetOutsideFunction` option or use `sourceType: 'script'`.");
		}
		return options;
	}
	const { defineProperty } = Object;
	const toUnenumerable = (object, key) => {
		if (object) defineProperty(object, key, {
			enumerable: false,
			value: object[key]
		});
	};
	function toESTreeLocation(node) {
		toUnenumerable(node.loc.start, "index");
		toUnenumerable(node.loc.end, "index");
		return node;
	}
	var estree = (superClass) => class ESTreeParserMixin extends superClass {
		parse() {
			const file = toESTreeLocation(super.parse());
			if (this.optionFlags & 256) file.tokens = file.tokens.map(toESTreeLocation);
			return file;
		}
		parseRegExpLiteral({ pattern, flags }) {
			let regex = null;
			try {
				regex = new RegExp(pattern, flags);
			} catch (_) {}
			const node = this.estreeParseLiteral(regex);
			node.regex = {
				pattern,
				flags
			};
			return node;
		}
		parseBigIntLiteral(value) {
			let bigInt;
			try {
				bigInt = BigInt(value);
			} catch (_unused) {
				bigInt = null;
			}
			const node = this.estreeParseLiteral(bigInt);
			node.bigint = String(node.value || value);
			return node;
		}
		parseDecimalLiteral(value) {
			const node = this.estreeParseLiteral(null);
			node.decimal = String(node.value || value);
			return node;
		}
		estreeParseLiteral(value) {
			return this.parseLiteral(value, "Literal");
		}
		parseStringLiteral(value) {
			return this.estreeParseLiteral(value);
		}
		parseNumericLiteral(value) {
			return this.estreeParseLiteral(value);
		}
		parseNullLiteral() {
			return this.estreeParseLiteral(null);
		}
		parseBooleanLiteral(value) {
			return this.estreeParseLiteral(value);
		}
		estreeParseChainExpression(node, endLoc) {
			const chain = this.startNodeAtNode(node);
			chain.expression = node;
			return this.finishNodeAt(chain, "ChainExpression", endLoc);
		}
		directiveToStmt(directive) {
			const expression = directive.value;
			delete directive.value;
			this.castNodeTo(expression, "Literal");
			expression.raw = expression.extra.raw;
			expression.value = expression.extra.expressionValue;
			const stmt = this.castNodeTo(directive, "ExpressionStatement");
			stmt.expression = expression;
			stmt.directive = expression.extra.rawValue;
			delete expression.extra;
			return stmt;
		}
		fillOptionalPropertiesForTSESLint(node) {}
		cloneEstreeStringLiteral(node) {
			const { start, end, loc, range, raw, value } = node;
			const cloned = Object.create(node.constructor.prototype);
			cloned.type = "Literal";
			cloned.start = start;
			cloned.end = end;
			cloned.loc = loc;
			cloned.range = range;
			cloned.raw = raw;
			cloned.value = value;
			return cloned;
		}
		initFunction(node, isAsync) {
			super.initFunction(node, isAsync);
			node.expression = false;
		}
		checkDeclaration(node) {
			if (node != null && this.isObjectProperty(node)) this.checkDeclaration(node.value);
			else super.checkDeclaration(node);
		}
		getObjectOrClassMethodParams(method) {
			return method.value.params;
		}
		isValidDirective(stmt) {
			var _stmt$expression$extr;
			return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);
		}
		parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
			super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);
			node.body = node.directives.map((d) => this.directiveToStmt(d)).concat(node.body);
			delete node.directives;
		}
		parsePrivateName() {
			const node = super.parsePrivateName();
			if (!this.getPluginOption("estree", "classFeatures")) return node;
			return this.convertPrivateNameToPrivateIdentifier(node);
		}
		convertPrivateNameToPrivateIdentifier(node) {
			const name = super.getPrivateNameSV(node);
			delete node.id;
			node.name = name;
			return this.castNodeTo(node, "PrivateIdentifier");
		}
		isPrivateName(node) {
			if (!this.getPluginOption("estree", "classFeatures")) return super.isPrivateName(node);
			return node.type === "PrivateIdentifier";
		}
		getPrivateNameSV(node) {
			if (!this.getPluginOption("estree", "classFeatures")) return super.getPrivateNameSV(node);
			return node.name;
		}
		parseLiteral(value, type) {
			const node = super.parseLiteral(value, type);
			node.raw = node.extra.raw;
			delete node.extra;
			return node;
		}
		parseFunctionBody(node, allowExpression, isMethod = false) {
			super.parseFunctionBody(node, allowExpression, isMethod);
			node.expression = node.body.type !== "BlockStatement";
		}
		parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
			let funcNode = this.startNode();
			funcNode.kind = node.kind;
			funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
			delete funcNode.kind;
			const { typeParameters } = node;
			if (typeParameters) {
				delete node.typeParameters;
				funcNode.typeParameters = typeParameters;
				this.resetStartLocationFromNode(funcNode, typeParameters);
			}
			node.value = this.castNodeTo(funcNode, "FunctionExpression");
			if (type === "ClassPrivateMethod") node.computed = false;
			if (type === "ObjectMethod") {
				if (node.kind === "method") node.kind = "init";
				node.shorthand = false;
				return this.finishNode(node, "Property");
			} else return this.finishNode(node, "MethodDefinition");
		}
		nameIsConstructor(key) {
			if (key.type === "Literal") return key.value === "constructor";
			return super.nameIsConstructor(key);
		}
		parseClassProperty(...args) {
			const propertyNode = super.parseClassProperty(...args);
			if (!this.getPluginOption("estree", "classFeatures")) return propertyNode;
			this.castNodeTo(propertyNode, "PropertyDefinition");
			return propertyNode;
		}
		parseClassPrivateProperty(...args) {
			const propertyNode = super.parseClassPrivateProperty(...args);
			if (!this.getPluginOption("estree", "classFeatures")) return propertyNode;
			this.castNodeTo(propertyNode, "PropertyDefinition");
			propertyNode.computed = false;
			return propertyNode;
		}
		parseClassAccessorProperty(node) {
			const accessorPropertyNode = super.parseClassAccessorProperty(node);
			if (!this.getPluginOption("estree", "classFeatures")) return accessorPropertyNode;
			if (accessorPropertyNode.abstract && this.hasPlugin("typescript")) {
				delete accessorPropertyNode.abstract;
				this.castNodeTo(accessorPropertyNode, "TSAbstractAccessorProperty");
			} else this.castNodeTo(accessorPropertyNode, "AccessorProperty");
			return accessorPropertyNode;
		}
		parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
			const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
			if (node) {
				node.kind = "init";
				this.castNodeTo(node, "Property");
			}
			return node;
		}
		finishObjectProperty(node) {
			node.kind = "init";
			return this.finishNode(node, "Property");
		}
		isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {
			return type === "Property" ? "value" : super.isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding);
		}
		isAssignable(node, isBinding) {
			if (node != null && this.isObjectProperty(node)) return this.isAssignable(node.value, isBinding);
			return super.isAssignable(node, isBinding);
		}
		toAssignable(node, isLHS = false) {
			if (node != null && this.isObjectProperty(node)) {
				const { key, value } = node;
				if (this.isPrivateName(key)) this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
				this.toAssignable(value, isLHS);
			} else super.toAssignable(node, isLHS);
		}
		toAssignableObjectExpressionProp(prop, isLast, isLHS) {
			if (prop.type === "Property" && (prop.kind === "get" || prop.kind === "set")) this.raise(Errors.PatternHasAccessor, prop.key);
			else if (prop.type === "Property" && prop.method) this.raise(Errors.PatternHasMethod, prop.key);
			else super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
		}
		finishCallExpression(unfinished, optional) {
			const node = super.finishCallExpression(unfinished, optional);
			if (node.callee.type === "Import") {
				var _ref, _ref2;
				this.castNodeTo(node, "ImportExpression");
				node.source = node.arguments[0];
				node.options = (_ref = node.arguments[1]) != null ? _ref : null;
				node.attributes = (_ref2 = node.arguments[1]) != null ? _ref2 : null;
				delete node.arguments;
				delete node.callee;
			} else if (node.type === "OptionalCallExpression") this.castNodeTo(node, "CallExpression");
			else node.optional = false;
			return node;
		}
		toReferencedArguments(node) {
			if (node.type === "ImportExpression") return;
			super.toReferencedArguments(node);
		}
		parseExport(unfinished, decorators) {
			const exportStartLoc = this.state.lastTokStartLoc;
			const node = super.parseExport(unfinished, decorators);
			switch (node.type) {
				case "ExportAllDeclaration":
					node.exported = null;
					break;
				case "ExportNamedDeclaration": if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
					this.castNodeTo(node, "ExportAllDeclaration");
					node.exported = node.specifiers[0].exported;
					delete node.specifiers;
				}
				case "ExportDefaultDeclaration": {
					var _declaration$decorato;
					const { declaration } = node;
					if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) this.resetStartLocation(node, exportStartLoc);
				}
			}
			return node;
		}
		stopParseSubscript(base, state) {
			const node = super.stopParseSubscript(base, state);
			if (state.optionalChainMember) return this.estreeParseChainExpression(node, base.loc.end);
			return node;
		}
		parseMember(base, startLoc, state, computed, optional) {
			const node = super.parseMember(base, startLoc, state, computed, optional);
			if (node.type === "OptionalMemberExpression") this.castNodeTo(node, "MemberExpression");
			else node.optional = false;
			return node;
		}
		isOptionalMemberExpression(node) {
			if (node.type === "ChainExpression") return node.expression.type === "MemberExpression";
			return super.isOptionalMemberExpression(node);
		}
		hasPropertyAsPrivateName(node) {
			if (node.type === "ChainExpression") node = node.expression;
			return super.hasPropertyAsPrivateName(node);
		}
		isObjectProperty(node) {
			return node.type === "Property" && node.kind === "init" && !node.method;
		}
		isObjectMethod(node) {
			return node.type === "Property" && (node.method || node.kind === "get" || node.kind === "set");
		}
		castNodeTo(node, type) {
			const result = super.castNodeTo(node, type);
			this.fillOptionalPropertiesForTSESLint(result);
			return result;
		}
		cloneIdentifier(node) {
			const cloned = super.cloneIdentifier(node);
			this.fillOptionalPropertiesForTSESLint(cloned);
			return cloned;
		}
		cloneStringLiteral(node) {
			if (node.type === "Literal") return this.cloneEstreeStringLiteral(node);
			return super.cloneStringLiteral(node);
		}
		finishNodeAt(node, type, endLoc) {
			return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
		}
		finishNode(node, type) {
			const result = super.finishNode(node, type);
			this.fillOptionalPropertiesForTSESLint(result);
			return result;
		}
		resetStartLocation(node, startLoc) {
			super.resetStartLocation(node, startLoc);
			toESTreeLocation(node);
		}
		resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
			super.resetEndLocation(node, endLoc);
			toESTreeLocation(node);
		}
	};
	var TokContext = class {
		constructor(token, preserveSpace) {
			this.token = void 0;
			this.preserveSpace = void 0;
			this.token = token;
			this.preserveSpace = !!preserveSpace;
		}
	};
	const types = {
		brace: new TokContext("{"),
		j_oTag: new TokContext("<tag"),
		j_cTag: new TokContext("</tag"),
		j_expr: new TokContext("<tag>...</tag>", true)
	};
	types.template = new TokContext("`", true);
	const beforeExpr = true;
	const startsExpr = true;
	const isLoop = true;
	const isAssign = true;
	const prefix = true;
	const postfix = true;
	var ExportedTokenType = class {
		constructor(label, conf = {}) {
			this.label = void 0;
			this.keyword = void 0;
			this.beforeExpr = void 0;
			this.startsExpr = void 0;
			this.rightAssociative = void 0;
			this.isLoop = void 0;
			this.isAssign = void 0;
			this.prefix = void 0;
			this.postfix = void 0;
			this.binop = void 0;
			this.label = label;
			this.keyword = conf.keyword;
			this.beforeExpr = !!conf.beforeExpr;
			this.startsExpr = !!conf.startsExpr;
			this.rightAssociative = !!conf.rightAssociative;
			this.isLoop = !!conf.isLoop;
			this.isAssign = !!conf.isAssign;
			this.prefix = !!conf.prefix;
			this.postfix = !!conf.postfix;
			this.binop = conf.binop != null ? conf.binop : null;
			this.updateContext = null;
		}
	};
	const keywords$1 = /* @__PURE__ */ new Map();
	function createKeyword(name, options = {}) {
		options.keyword = name;
		const token = createToken(name, options);
		keywords$1.set(name, token);
		return token;
	}
	function createBinop(name, binop) {
		return createToken(name, {
			beforeExpr,
			binop
		});
	}
	let tokenTypeCounter = -1;
	const tokenTypes = [];
	const tokenLabels = [];
	const tokenBinops = [];
	const tokenBeforeExprs = [];
	const tokenStartsExprs = [];
	const tokenPrefixes = [];
	function createToken(name, options = {}) {
		var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
		++tokenTypeCounter;
		tokenLabels.push(name);
		tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
		tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
		tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
		tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
		tokenTypes.push(new ExportedTokenType(name, options));
		return tokenTypeCounter;
	}
	function createKeywordLike(name, options = {}) {
		var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
		++tokenTypeCounter;
		keywords$1.set(name, tokenTypeCounter);
		tokenLabels.push(name);
		tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
		tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
		tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
		tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
		tokenTypes.push(new ExportedTokenType("name", options));
		return tokenTypeCounter;
	}
	const tt = {
		bracketL: createToken("[", {
			beforeExpr,
			startsExpr
		}),
		bracketHashL: createToken("#[", {
			beforeExpr,
			startsExpr
		}),
		bracketBarL: createToken("[|", {
			beforeExpr,
			startsExpr
		}),
		bracketR: createToken("]"),
		bracketBarR: createToken("|]"),
		braceL: createToken("{", {
			beforeExpr,
			startsExpr
		}),
		braceBarL: createToken("{|", {
			beforeExpr,
			startsExpr
		}),
		braceHashL: createToken("#{", {
			beforeExpr,
			startsExpr
		}),
		braceR: createToken("}"),
		braceBarR: createToken("|}"),
		parenL: createToken("(", {
			beforeExpr,
			startsExpr
		}),
		parenR: createToken(")"),
		comma: createToken(",", { beforeExpr }),
		semi: createToken(";", { beforeExpr }),
		colon: createToken(":", { beforeExpr }),
		doubleColon: createToken("::", { beforeExpr }),
		dot: createToken("."),
		question: createToken("?", { beforeExpr }),
		questionDot: createToken("?."),
		arrow: createToken("=>", { beforeExpr }),
		template: createToken("template"),
		ellipsis: createToken("...", { beforeExpr }),
		backQuote: createToken("`", { startsExpr }),
		dollarBraceL: createToken("${", {
			beforeExpr,
			startsExpr
		}),
		templateTail: createToken("...`", { startsExpr }),
		templateNonTail: createToken("...${", {
			beforeExpr,
			startsExpr
		}),
		at: createToken("@"),
		hash: createToken("#", { startsExpr }),
		interpreterDirective: createToken("#!..."),
		eq: createToken("=", {
			beforeExpr,
			isAssign
		}),
		assign: createToken("_=", {
			beforeExpr,
			isAssign
		}),
		slashAssign: createToken("_=", {
			beforeExpr,
			isAssign
		}),
		xorAssign: createToken("_=", {
			beforeExpr,
			isAssign
		}),
		moduloAssign: createToken("_=", {
			beforeExpr,
			isAssign
		}),
		incDec: createToken("++/--", {
			prefix,
			postfix,
			startsExpr
		}),
		bang: createToken("!", {
			beforeExpr,
			prefix,
			startsExpr
		}),
		tilde: createToken("~", {
			beforeExpr,
			prefix,
			startsExpr
		}),
		doubleCaret: createToken("^^", { startsExpr }),
		doubleAt: createToken("@@", { startsExpr }),
		pipeline: createBinop("|>", 0),
		nullishCoalescing: createBinop("??", 1),
		logicalOR: createBinop("||", 1),
		logicalAND: createBinop("&&", 2),
		bitwiseOR: createBinop("|", 3),
		bitwiseXOR: createBinop("^", 4),
		bitwiseAND: createBinop("&", 5),
		equality: createBinop("==/!=/===/!==", 6),
		lt: createBinop("</>/<=/>=", 7),
		gt: createBinop("</>/<=/>=", 7),
		relational: createBinop("</>/<=/>=", 7),
		bitShift: createBinop("<</>>/>>>", 8),
		bitShiftL: createBinop("<</>>/>>>", 8),
		bitShiftR: createBinop("<</>>/>>>", 8),
		plusMin: createToken("+/-", {
			beforeExpr,
			binop: 9,
			prefix,
			startsExpr
		}),
		modulo: createToken("%", {
			binop: 10,
			startsExpr
		}),
		star: createToken("*", { binop: 10 }),
		slash: createBinop("/", 10),
		exponent: createToken("**", {
			beforeExpr,
			binop: 11,
			rightAssociative: true
		}),
		_in: createKeyword("in", {
			beforeExpr,
			binop: 7
		}),
		_instanceof: createKeyword("instanceof", {
			beforeExpr,
			binop: 7
		}),
		_break: createKeyword("break"),
		_case: createKeyword("case", { beforeExpr }),
		_catch: createKeyword("catch"),
		_continue: createKeyword("continue"),
		_debugger: createKeyword("debugger"),
		_default: createKeyword("default", { beforeExpr }),
		_else: createKeyword("else", { beforeExpr }),
		_finally: createKeyword("finally"),
		_function: createKeyword("function", { startsExpr }),
		_if: createKeyword("if"),
		_return: createKeyword("return", { beforeExpr }),
		_switch: createKeyword("switch"),
		_throw: createKeyword("throw", {
			beforeExpr,
			prefix,
			startsExpr
		}),
		_try: createKeyword("try"),
		_var: createKeyword("var"),
		_const: createKeyword("const"),
		_with: createKeyword("with"),
		_new: createKeyword("new", {
			beforeExpr,
			startsExpr
		}),
		_this: createKeyword("this", { startsExpr }),
		_super: createKeyword("super", { startsExpr }),
		_class: createKeyword("class", { startsExpr }),
		_extends: createKeyword("extends", { beforeExpr }),
		_export: createKeyword("export"),
		_import: createKeyword("import", { startsExpr }),
		_null: createKeyword("null", { startsExpr }),
		_true: createKeyword("true", { startsExpr }),
		_false: createKeyword("false", { startsExpr }),
		_typeof: createKeyword("typeof", {
			beforeExpr,
			prefix,
			startsExpr
		}),
		_void: createKeyword("void", {
			beforeExpr,
			prefix,
			startsExpr
		}),
		_delete: createKeyword("delete", {
			beforeExpr,
			prefix,
			startsExpr
		}),
		_do: createKeyword("do", {
			isLoop,
			beforeExpr
		}),
		_for: createKeyword("for", { isLoop }),
		_while: createKeyword("while", { isLoop }),
		_as: createKeywordLike("as", { startsExpr }),
		_assert: createKeywordLike("assert", { startsExpr }),
		_async: createKeywordLike("async", { startsExpr }),
		_await: createKeywordLike("await", { startsExpr }),
		_defer: createKeywordLike("defer", { startsExpr }),
		_from: createKeywordLike("from", { startsExpr }),
		_get: createKeywordLike("get", { startsExpr }),
		_let: createKeywordLike("let", { startsExpr }),
		_meta: createKeywordLike("meta", { startsExpr }),
		_of: createKeywordLike("of", { startsExpr }),
		_sent: createKeywordLike("sent", { startsExpr }),
		_set: createKeywordLike("set", { startsExpr }),
		_source: createKeywordLike("source", { startsExpr }),
		_static: createKeywordLike("static", { startsExpr }),
		_using: createKeywordLike("using", { startsExpr }),
		_yield: createKeywordLike("yield", { startsExpr }),
		_asserts: createKeywordLike("asserts", { startsExpr }),
		_checks: createKeywordLike("checks", { startsExpr }),
		_exports: createKeywordLike("exports", { startsExpr }),
		_global: createKeywordLike("global", { startsExpr }),
		_implements: createKeywordLike("implements", { startsExpr }),
		_intrinsic: createKeywordLike("intrinsic", { startsExpr }),
		_infer: createKeywordLike("infer", { startsExpr }),
		_is: createKeywordLike("is", { startsExpr }),
		_mixins: createKeywordLike("mixins", { startsExpr }),
		_proto: createKeywordLike("proto", { startsExpr }),
		_require: createKeywordLike("require", { startsExpr }),
		_satisfies: createKeywordLike("satisfies", { startsExpr }),
		_keyof: createKeywordLike("keyof", { startsExpr }),
		_readonly: createKeywordLike("readonly", { startsExpr }),
		_unique: createKeywordLike("unique", { startsExpr }),
		_abstract: createKeywordLike("abstract", { startsExpr }),
		_declare: createKeywordLike("declare", { startsExpr }),
		_enum: createKeywordLike("enum", { startsExpr }),
		_module: createKeywordLike("module", { startsExpr }),
		_namespace: createKeywordLike("namespace", { startsExpr }),
		_interface: createKeywordLike("interface", { startsExpr }),
		_type: createKeywordLike("type", { startsExpr }),
		_opaque: createKeywordLike("opaque", { startsExpr }),
		name: createToken("name", { startsExpr }),
		placeholder: createToken("%%", { startsExpr }),
		string: createToken("string", { startsExpr }),
		num: createToken("num", { startsExpr }),
		bigint: createToken("bigint", { startsExpr }),
		decimal: createToken("decimal", { startsExpr }),
		regexp: createToken("regexp", { startsExpr }),
		privateName: createToken("#name", { startsExpr }),
		eof: createToken("eof"),
		jsxName: createToken("jsxName"),
		jsxText: createToken("jsxText", { beforeExpr }),
		jsxTagStart: createToken("jsxTagStart", { startsExpr }),
		jsxTagEnd: createToken("jsxTagEnd")
	};
	function tokenIsIdentifier(token) {
		return token >= 93 && token <= 133;
	}
	function tokenKeywordOrIdentifierIsKeyword(token) {
		return token <= 92;
	}
	function tokenIsKeywordOrIdentifier(token) {
		return token >= 58 && token <= 133;
	}
	function tokenIsLiteralPropertyName(token) {
		return token >= 58 && token <= 137;
	}
	function tokenComesBeforeExpression(token) {
		return tokenBeforeExprs[token];
	}
	function tokenCanStartExpression(token) {
		return tokenStartsExprs[token];
	}
	function tokenIsAssignment(token) {
		return token >= 29 && token <= 33;
	}
	function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
		return token >= 129 && token <= 131;
	}
	function tokenIsLoop(token) {
		return token >= 90 && token <= 92;
	}
	function tokenIsKeyword(token) {
		return token >= 58 && token <= 92;
	}
	function tokenIsOperator(token) {
		return token >= 39 && token <= 59;
	}
	function tokenIsPostfix(token) {
		return token === 34;
	}
	function tokenIsPrefix(token) {
		return tokenPrefixes[token];
	}
	function tokenIsTSTypeOperator(token) {
		return token >= 121 && token <= 123;
	}
	function tokenIsTSDeclarationStart(token) {
		return token >= 124 && token <= 130;
	}
	function tokenLabelName(token) {
		return tokenLabels[token];
	}
	function tokenOperatorPrecedence(token) {
		return tokenBinops[token];
	}
	function tokenIsRightAssociative(token) {
		return token === 57;
	}
	function tokenIsTemplate(token) {
		return token >= 24 && token <= 25;
	}
	function getExportedToken(token) {
		return tokenTypes[token];
	}
	tokenTypes[8].updateContext = (context) => {
		context.pop();
	};
	tokenTypes[5].updateContext = tokenTypes[7].updateContext = tokenTypes[23].updateContext = (context) => {
		context.push(types.brace);
	};
	tokenTypes[22].updateContext = (context) => {
		if (context[context.length - 1] === types.template) context.pop();
		else context.push(types.template);
	};
	tokenTypes[143].updateContext = (context) => {
		context.push(types.j_expr, types.j_oTag);
	};
	let nonASCIIidentifierStartChars = "ªµºÀ-ÖØ-öø-ˁˆ-ˑˠ-ˤˬˮͰ-ʹͶͷͺ-ͽͿΆΈ-ΊΌΎ-ΡΣ-ϵϷ-ҁҊ-ԯԱ-Ֆՙՠ-ֈא-תׯ-ײؠ-يٮٯٱ-ۓەۥۦۮۯۺ-ۼۿܐܒ-ܯݍ-ޥޱߊ-ߪߴߵߺࠀ-ࠕࠚࠤࠨࡀ-ࡘࡠ-ࡪࡰ-ࢇࢉ-࢏ࢠ-ࣉऄ-हऽॐक़-ॡॱ-ঀঅ-ঌএঐও-নপ-রলশ-হঽৎড়ঢ়য়-ৡৰৱৼਅ-ਊਏਐਓ-ਨਪ-ਰਲਲ਼ਵਸ਼ਸਹਖ਼-ੜਫ਼ੲ-ੴઅ-ઍએ-ઑઓ-નપ-રલળવ-હઽૐૠૡૹଅ-ଌଏଐଓ-ନପ-ରଲଳଵ-ହଽଡ଼ଢ଼ୟ-ୡୱஃஅ-ஊஎ-ஐஒ-கஙசஜஞடணதந-பம-ஹௐఅ-ఌఎ-ఐఒ-నప-హఽౘ-ౚ౜ౝౠౡಀಅ-ಌಎ-ಐಒ-ನಪ-ಳವ-ಹಽ೜-ೞೠೡೱೲഄ-ഌഎ-ഐഒ-ഺഽൎൔ-ൖൟ-ൡൺ-ൿඅ-ඖක-නඳ-රලව-ෆก-ะาำเ-ๆກຂຄຆ-ຊຌ-ຣລວ-ະາຳຽເ-ໄໆໜ-ໟༀཀ-ཇཉ-ཬྈ-ྌက-ဪဿၐ-ၕၚ-ၝၡၥၦၮ-ၰၵ-ႁႎႠ-ჅჇჍა-ჺჼ-ቈቊ-ቍቐ-ቖቘቚ-ቝበ-ኈኊ-ኍነ-ኰኲ-ኵኸ-ኾዀዂ-ዅወ-ዖዘ-ጐጒ-ጕጘ-ፚᎀ-ᎏᎠ-Ᏽᏸ-ᏽᐁ-ᙬᙯ-ᙿᚁ-ᚚᚠ-ᛪᛮ-ᛸᜀ-ᜑᜟ-ᜱᝀ-ᝑᝠ-ᝬᝮ-ᝰក-ឳៗៜᠠ-ᡸᢀ-ᢨᢪᢰ-ᣵᤀ-ᤞᥐ-ᥭᥰ-ᥴᦀ-ᦫᦰ-ᧉᨀ-ᨖᨠ-ᩔᪧᬅ-ᬳᭅ-ᭌᮃ-ᮠᮮᮯᮺ-ᯥᰀ-ᰣᱍ-ᱏᱚ-ᱽᲀ-ᲊᲐ-ᲺᲽ-Ჿᳩ-ᳬᳮ-ᳳᳵᳶᳺᴀ-ᶿḀ-ἕἘ-Ἕἠ-ὅὈ-Ὅὐ-ὗὙὛὝὟ-ώᾀ-ᾴᾶ-ᾼιῂ-ῄῆ-ῌῐ-ΐῖ-Ίῠ-Ῥῲ-ῴῶ-ῼⁱⁿₐ-ₜℂℇℊ-ℓℕ℘-ℝℤΩℨK-ℹℼ-ℿⅅ-ⅉⅎⅠ-ↈⰀ-ⳤⳫ-ⳮⳲⳳⴀ-ⴥⴧⴭⴰ-ⵧⵯⶀ-ⶖⶠ-ⶦⶨ-ⶮⶰ-ⶶⶸ-ⶾⷀ-ⷆⷈ-ⷎⷐ-ⷖⷘ-ⷞ々-〇〡-〩〱-〵〸-〼ぁ-ゖ゛-ゟァ-ヺー-ヿㄅ-ㄯㄱ-ㆎㆠ-ㆿㇰ-ㇿ㐀-䶿一-ꒌꓐ-ꓽꔀ-ꘌꘐ-ꘟꘪꘫꙀ-ꙮꙿ-ꚝꚠ-ꛯꜗ-ꜟꜢ-ꞈꞋ-Ƛ꟱-ꠁꠃ-ꠅꠇ-ꠊꠌ-ꠢꡀ-ꡳꢂ-ꢳꣲ-ꣷꣻꣽꣾꤊ-ꤥꤰ-ꥆꥠ-ꥼꦄ-ꦲꧏꧠ-ꧤꧦ-ꧯꧺ-ꧾꨀ-ꨨꩀ-ꩂꩄ-ꩋꩠ-ꩶꩺꩾ-ꪯꪱꪵꪶꪹ-ꪽꫀꫂꫛ-ꫝꫠ-ꫪꫲ-ꫴꬁ-ꬆꬉ-ꬎꬑ-ꬖꬠ-ꬦꬨ-ꬮꬰ-ꭚꭜ-ꭩꭰ-ꯢ가-힣ힰ-ퟆퟋ-ퟻ豈-舘並-龎ff-stﬓ-ﬗיִײַ-ﬨשׁ-זּטּ-לּמּנּסּףּפּצּ-ﮱﯓ-ﴽﵐ-ﶏﶒ-ﷇﷰ-ﷻﹰ-ﹴﹶ-ﻼＡ-Ｚａ-ｚｦ-ﾾￂ-ￇￊ-ￏￒ-ￗￚ-ￜ";
	let nonASCIIidentifierChars = "·̀-ͯ·҃-֑҇-ׇֽֿׁׂׅׄؐ-ًؚ-٩ٰۖ-ۜ۟-۪ۤۧۨ-ۭ۰-۹ܑܰ-݊ަ-ް߀-߉߫-߽߳ࠖ-࠙ࠛ-ࠣࠥ-ࠧࠩ-࡙࠭-࡛ࢗ-࢟࣊-ࣣ࣡-ःऺ-़ा-ॏ॑-ॗॢॣ०-९ঁ-ঃ়া-ৄেৈো-্ৗৢৣ০-৯৾ਁ-ਃ਼ਾ-ੂੇੈੋ-੍ੑ੦-ੱੵઁ-ઃ઼ા-ૅે-ૉો-્ૢૣ૦-૯ૺ-૿ଁ-ଃ଼ା-ୄେୈୋ-୍୕-ୗୢୣ୦-୯ஂா-ூெ-ைொ-்ௗ௦-௯ఀ-ఄ఼ా-ౄె-ైొ-్ౕౖౢౣ౦-౯ಁ-ಃ಼ಾ-ೄೆ-ೈೊ-್ೕೖೢೣ೦-೯ೳഀ-ഃ഻഼ാ-ൄെ-ൈൊ-്ൗൢൣ൦-൯ඁ-ඃ්ා-ුූෘ-ෟ෦-෯ෲෳัิ-ฺ็-๎๐-๙ັິ-ຼ່-໎໐-໙༘༙༠-༩༹༵༷༾༿ཱ-྄྆྇ྍ-ྗྙ-ྼ࿆ါ-ှ၀-၉ၖ-ၙၞ-ၠၢ-ၤၧ-ၭၱ-ၴႂ-ႍႏ-ႝ፝-፟፩-፱ᜒ-᜕ᜲ-᜴ᝒᝓᝲᝳ឴-៓៝០-៩᠋-᠍᠏-᠙ᢩᤠ-ᤫᤰ-᤻᥆-᥏᧐-᧚ᨗ-ᨛᩕ-ᩞ᩠-᩿᩼-᪉᪐-᪙᪰-᪽ᪿ-᫝᫠-᫫ᬀ-ᬄ᬴-᭄᭐-᭙᭫-᭳ᮀ-ᮂᮡ-ᮭ᮰-᮹᯦-᯳ᰤ-᰷᱀-᱉᱐-᱙᳐-᳔᳒-᳨᳭᳴᳷-᳹᷀-᷿‌‍‿⁀⁔⃐-⃥⃜⃡-⃰⳯-⵿⳱ⷠ-〪ⷿ-゙゚〯・꘠-꘩꙯ꙴ-꙽ꚞꚟ꛰꛱ꠂ꠆ꠋꠣ-ꠧ꠬ꢀꢁꢴ-ꣅ꣐-꣙꣠-꣱ꣿ-꤉ꤦ-꤭ꥇ-꥓ꦀ-ꦃ꦳-꧀꧐-꧙ꧥ꧰-꧹ꨩ-ꨶꩃꩌꩍ꩐-꩙ꩻ-ꩽꪰꪲ-ꪴꪷꪸꪾ꪿꫁ꫫ-ꫯꫵ꫶ꯣ-ꯪ꯬꯭꯰-꯹ﬞ︀-️︠-︯︳︴﹍-﹏０-９＿･";
	const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
	const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
	nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
	const astralIdentifierStartCodes = [
		0,
		11,
		2,
		25,
		2,
		18,
		2,
		1,
		2,
		14,
		3,
		13,
		35,
		122,
		70,
		52,
		268,
		28,
		4,
		48,
		48,
		31,
		14,
		29,
		6,
		37,
		11,
		29,
		3,
		35,
		5,
		7,
		2,
		4,
		43,
		157,
		19,
		35,
		5,
		35,
		5,
		39,
		9,
		51,
		13,
		10,
		2,
		14,
		2,
		6,
		2,
		1,
		2,
		10,
		2,
		14,
		2,
		6,
		2,
		1,
		4,
		51,
		13,
		310,
		10,
		21,
		11,
		7,
		25,
		5,
		2,
		41,
		2,
		8,
		70,
		5,
		3,
		0,
		2,
		43,
		2,
		1,
		4,
		0,
		3,
		22,
		11,
		22,
		10,
		30,
		66,
		18,
		2,
		1,
		11,
		21,
		11,
		25,
		7,
		25,
		39,
		55,
		7,
		1,
		65,
		0,
		16,
		3,
		2,
		2,
		2,
		28,
		43,
		28,
		4,
		28,
		36,
		7,
		2,
		27,
		28,
		53,
		11,
		21,
		11,
		18,
		14,
		17,
		111,
		72,
		56,
		50,
		14,
		50,
		14,
		35,
		39,
		27,
		10,
		22,
		251,
		41,
		7,
		1,
		17,
		5,
		57,
		28,
		11,
		0,
		9,
		21,
		43,
		17,
		47,
		20,
		28,
		22,
		13,
		52,
		58,
		1,
		3,
		0,
		14,
		44,
		33,
		24,
		27,
		35,
		30,
		0,
		3,
		0,
		9,
		34,
		4,
		0,
		13,
		47,
		15,
		3,
		22,
		0,
		2,
		0,
		36,
		17,
		2,
		24,
		20,
		1,
		64,
		6,
		2,
		0,
		2,
		3,
		2,
		14,
		2,
		9,
		8,
		46,
		39,
		7,
		3,
		1,
		3,
		21,
		2,
		6,
		2,
		1,
		2,
		4,
		4,
		0,
		19,
		0,
		13,
		4,
		31,
		9,
		2,
		0,
		3,
		0,
		2,
		37,
		2,
		0,
		26,
		0,
		2,
		0,
		45,
		52,
		19,
		3,
		21,
		2,
		31,
		47,
		21,
		1,
		2,
		0,
		185,
		46,
		42,
		3,
		37,
		47,
		21,
		0,
		60,
		42,
		14,
		0,
		72,
		26,
		38,
		6,
		186,
		43,
		117,
		63,
		32,
		7,
		3,
		0,
		3,
		7,
		2,
		1,
		2,
		23,
		16,
		0,
		2,
		0,
		95,
		7,
		3,
		38,
		17,
		0,
		2,
		0,
		29,
		0,
		11,
		39,
		8,
		0,
		22,
		0,
		12,
		45,
		20,
		0,
		19,
		72,
		200,
		32,
		32,
		8,
		2,
		36,
		18,
		0,
		50,
		29,
		113,
		6,
		2,
		1,
		2,
		37,
		22,
		0,
		26,
		5,
		2,
		1,
		2,
		31,
		15,
		0,
		24,
		43,
		261,
		18,
		16,
		0,
		2,
		12,
		2,
		33,
		125,
		0,
		80,
		921,
		103,
		110,
		18,
		195,
		2637,
		96,
		16,
		1071,
		18,
		5,
		26,
		3994,
		6,
		582,
		6842,
		29,
		1763,
		568,
		8,
		30,
		18,
		78,
		18,
		29,
		19,
		47,
		17,
		3,
		32,
		20,
		6,
		18,
		433,
		44,
		212,
		63,
		33,
		24,
		3,
		24,
		45,
		74,
		6,
		0,
		67,
		12,
		65,
		1,
		2,
		0,
		15,
		4,
		10,
		7381,
		42,
		31,
		98,
		114,
		8702,
		3,
		2,
		6,
		2,
		1,
		2,
		290,
		16,
		0,
		30,
		2,
		3,
		0,
		15,
		3,
		9,
		395,
		2309,
		106,
		6,
		12,
		4,
		8,
		8,
		9,
		5991,
		84,
		2,
		70,
		2,
		1,
		3,
		0,
		3,
		1,
		3,
		3,
		2,
		11,
		2,
		0,
		2,
		6,
		2,
		64,
		2,
		3,
		3,
		7,
		2,
		6,
		2,
		27,
		2,
		3,
		2,
		4,
		2,
		0,
		4,
		6,
		2,
		339,
		3,
		24,
		2,
		24,
		2,
		30,
		2,
		24,
		2,
		30,
		2,
		24,
		2,
		30,
		2,
		24,
		2,
		30,
		2,
		24,
		2,
		7,
		1845,
		30,
		7,
		5,
		262,
		61,
		147,
		44,
		11,
		6,
		17,
		0,
		322,
		29,
		19,
		43,
		485,
		27,
		229,
		29,
		3,
		0,
		208,
		30,
		2,
		2,
		2,
		1,
		2,
		6,
		3,
		4,
		10,
		1,
		225,
		6,
		2,
		3,
		2,
		1,
		2,
		14,
		2,
		196,
		60,
		67,
		8,
		0,
		1205,
		3,
		2,
		26,
		2,
		1,
		2,
		0,
		3,
		0,
		2,
		9,
		2,
		3,
		2,
		0,
		2,
		0,
		7,
		0,
		5,
		0,
		2,
		0,
		2,
		0,
		2,
		2,
		2,
		1,
		2,
		0,
		3,
		0,
		2,
		0,
		2,
		0,
		2,
		0,
		2,
		0,
		2,
		1,
		2,
		0,
		3,
		3,
		2,
		6,
		2,
		3,
		2,
		3,
		2,
		0,
		2,
		9,
		2,
		16,
		6,
		2,
		2,
		4,
		2,
		16,
		4421,
		42719,
		33,
		4381,
		3,
		5773,
		3,
		7472,
		16,
		621,
		2467,
		541,
		1507,
		4938,
		6,
		8489
	];
	const astralIdentifierCodes = [
		509,
		0,
		227,
		0,
		150,
		4,
		294,
		9,
		1368,
		2,
		2,
		1,
		6,
		3,
		41,
		2,
		5,
		0,
		166,
		1,
		574,
		3,
		9,
		9,
		7,
		9,
		32,
		4,
		318,
		1,
		78,
		5,
		71,
		10,
		50,
		3,
		123,
		2,
		54,
		14,
		32,
		10,
		3,
		1,
		11,
		3,
		46,
		10,
		8,
		0,
		46,
		9,
		7,
		2,
		37,
		13,
		2,
		9,
		6,
		1,
		45,
		0,
		13,
		2,
		49,
		13,
		9,
		3,
		2,
		11,
		83,
		11,
		7,
		0,
		3,
		0,
		158,
		11,
		6,
		9,
		7,
		3,
		56,
		1,
		2,
		6,
		3,
		1,
		3,
		2,
		10,
		0,
		11,
		1,
		3,
		6,
		4,
		4,
		68,
		8,
		2,
		0,
		3,
		0,
		2,
		3,
		2,
		4,
		2,
		0,
		15,
		1,
		83,
		17,
		10,
		9,
		5,
		0,
		82,
		19,
		13,
		9,
		214,
		6,
		3,
		8,
		28,
		1,
		83,
		16,
		16,
		9,
		82,
		12,
		9,
		9,
		7,
		19,
		58,
		14,
		5,
		9,
		243,
		14,
		166,
		9,
		71,
		5,
		2,
		1,
		3,
		3,
		2,
		0,
		2,
		1,
		13,
		9,
		120,
		6,
		3,
		6,
		4,
		0,
		29,
		9,
		41,
		6,
		2,
		3,
		9,
		0,
		10,
		10,
		47,
		15,
		199,
		7,
		137,
		9,
		54,
		7,
		2,
		7,
		17,
		9,
		57,
		21,
		2,
		13,
		123,
		5,
		4,
		0,
		2,
		1,
		2,
		6,
		2,
		0,
		9,
		9,
		49,
		4,
		2,
		1,
		2,
		4,
		9,
		9,
		55,
		9,
		266,
		3,
		10,
		1,
		2,
		0,
		49,
		6,
		4,
		4,
		14,
		10,
		5350,
		0,
		7,
		14,
		11465,
		27,
		2343,
		9,
		87,
		9,
		39,
		4,
		60,
		6,
		26,
		9,
		535,
		9,
		470,
		0,
		2,
		54,
		8,
		3,
		82,
		0,
		12,
		1,
		19628,
		1,
		4178,
		9,
		519,
		45,
		3,
		22,
		543,
		4,
		4,
		5,
		9,
		7,
		3,
		6,
		31,
		3,
		149,
		2,
		1418,
		49,
		513,
		54,
		5,
		49,
		9,
		0,
		15,
		0,
		23,
		4,
		2,
		14,
		1361,
		6,
		2,
		16,
		3,
		6,
		2,
		1,
		2,
		4,
		101,
		0,
		161,
		6,
		10,
		9,
		357,
		0,
		62,
		13,
		499,
		13,
		245,
		1,
		2,
		9,
		233,
		0,
		3,
		0,
		8,
		1,
		6,
		0,
		475,
		6,
		110,
		6,
		6,
		9,
		4759,
		9,
		787719,
		239
	];
	function isInAstralSet(code, set) {
		let pos = 65536;
		for (let i = 0, length = set.length; i < length; i += 2) {
			pos += set[i];
			if (pos > code) return false;
			pos += set[i + 1];
			if (pos >= code) return true;
		}
		return false;
	}
	function isIdentifierStart(code) {
		if (code < 65) return code === 36;
		if (code <= 90) return true;
		if (code < 97) return code === 95;
		if (code <= 122) return true;
		if (code <= 65535) return code >= 170 && nonASCIIidentifierStart.test(String.fromCharCode(code));
		return isInAstralSet(code, astralIdentifierStartCodes);
	}
	function isIdentifierChar(code) {
		if (code < 48) return code === 36;
		if (code < 58) return true;
		if (code < 65) return false;
		if (code <= 90) return true;
		if (code < 97) return code === 95;
		if (code <= 122) return true;
		if (code <= 65535) return code >= 170 && nonASCIIidentifier.test(String.fromCharCode(code));
		return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
	}
	const reservedWords = {
		keyword: [
			"break",
			"case",
			"catch",
			"continue",
			"debugger",
			"default",
			"do",
			"else",
			"finally",
			"for",
			"function",
			"if",
			"return",
			"switch",
			"throw",
			"try",
			"var",
			"const",
			"while",
			"with",
			"new",
			"this",
			"super",
			"class",
			"extends",
			"export",
			"import",
			"null",
			"true",
			"false",
			"in",
			"instanceof",
			"typeof",
			"void",
			"delete"
		],
		strict: [
			"implements",
			"interface",
			"let",
			"package",
			"private",
			"protected",
			"public",
			"static",
			"yield"
		],
		strictBind: ["eval", "arguments"]
	};
	const keywords = new Set(reservedWords.keyword);
	const reservedWordsStrictSet = new Set(reservedWords.strict);
	const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
	function isReservedWord(word, inModule) {
		return inModule && word === "await" || word === "enum";
	}
	function isStrictReservedWord(word, inModule) {
		return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
	}
	function isStrictBindOnlyReservedWord(word) {
		return reservedWordsStrictBindSet.has(word);
	}
	function isStrictBindReservedWord(word, inModule) {
		return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
	}
	function isKeyword(word) {
		return keywords.has(word);
	}
	function isIteratorStart(current, next, next2) {
		return current === 64 && next === 64 && isIdentifierStart(next2);
	}
	const reservedWordLikeSet = /* @__PURE__ */ new Set([
		"break",
		"case",
		"catch",
		"continue",
		"debugger",
		"default",
		"do",
		"else",
		"finally",
		"for",
		"function",
		"if",
		"return",
		"switch",
		"throw",
		"try",
		"var",
		"const",
		"while",
		"with",
		"new",
		"this",
		"super",
		"class",
		"extends",
		"export",
		"import",
		"null",
		"true",
		"false",
		"in",
		"instanceof",
		"typeof",
		"void",
		"delete",
		"implements",
		"interface",
		"let",
		"package",
		"private",
		"protected",
		"public",
		"static",
		"yield",
		"eval",
		"arguments",
		"enum",
		"await"
	]);
	function canBeReservedWord(word) {
		return reservedWordLikeSet.has(word);
	}
	var Scope = class {
		constructor(flags) {
			this.flags = 0;
			this.names = /* @__PURE__ */ new Map();
			this.firstLexicalName = "";
			this.flags = flags;
		}
	};
	var ScopeHandler = class {
		constructor(parser, inModule) {
			this.parser = void 0;
			this.scopeStack = [];
			this.inModule = void 0;
			this.undefinedExports = /* @__PURE__ */ new Map();
			this.parser = parser;
			this.inModule = inModule;
		}
		get inTopLevel() {
			return (this.currentScope().flags & 1) > 0;
		}
		get inFunction() {
			return (this.currentVarScopeFlags() & 2) > 0;
		}
		get allowSuper() {
			return (this.currentThisScopeFlags() & 16) > 0;
		}
		get allowDirectSuper() {
			return (this.currentThisScopeFlags() & 32) > 0;
		}
		get allowNewTarget() {
			return (this.currentThisScopeFlags() & 512) > 0;
		}
		get inClass() {
			return (this.currentThisScopeFlags() & 64) > 0;
		}
		get inClassAndNotInNonArrowFunction() {
			const flags = this.currentThisScopeFlags();
			return (flags & 64) > 0 && (flags & 2) === 0;
		}
		get inStaticBlock() {
			for (let i = this.scopeStack.length - 1;; i--) {
				const { flags } = this.scopeStack[i];
				if (flags & 128) return true;
				if (flags & 1731) return false;
			}
		}
		get inNonArrowFunction() {
			return (this.currentThisScopeFlags() & 2) > 0;
		}
		get inBareCaseStatement() {
			return (this.currentScope().flags & 256) > 0;
		}
		get treatFunctionsAsVar() {
			return this.treatFunctionsAsVarInScope(this.currentScope());
		}
		createScope(flags) {
			return new Scope(flags);
		}
		enter(flags) {
			this.scopeStack.push(this.createScope(flags));
		}
		exit() {
			return this.scopeStack.pop().flags;
		}
		treatFunctionsAsVarInScope(scope) {
			return !!(scope.flags & 130 || !this.parser.inModule && scope.flags & 1);
		}
		declareName(name, bindingType, loc) {
			let scope = this.currentScope();
			if (bindingType & 8 || bindingType & 16) {
				this.checkRedeclarationInScope(scope, name, bindingType, loc);
				let type = scope.names.get(name) || 0;
				if (bindingType & 16) type = type | 4;
				else {
					if (!scope.firstLexicalName) scope.firstLexicalName = name;
					type = type | 2;
				}
				scope.names.set(name, type);
				if (bindingType & 8) this.maybeExportDefined(scope, name);
			} else if (bindingType & 4) for (let i = this.scopeStack.length - 1; i >= 0; --i) {
				scope = this.scopeStack[i];
				this.checkRedeclarationInScope(scope, name, bindingType, loc);
				scope.names.set(name, (scope.names.get(name) || 0) | 1);
				this.maybeExportDefined(scope, name);
				if (scope.flags & 1667) break;
			}
			if (this.parser.inModule && scope.flags & 1) this.undefinedExports.delete(name);
		}
		maybeExportDefined(scope, name) {
			if (this.parser.inModule && scope.flags & 1) this.undefinedExports.delete(name);
		}
		checkRedeclarationInScope(scope, name, bindingType, loc) {
			if (this.isRedeclaredInScope(scope, name, bindingType)) this.parser.raise(Errors.VarRedeclaration, loc, { identifierName: name });
		}
		isRedeclaredInScope(scope, name, bindingType) {
			if (!(bindingType & 1)) return false;
			if (bindingType & 8) return scope.names.has(name);
			const type = scope.names.get(name) || 0;
			if (bindingType & 16) return (type & 2) > 0 || !this.treatFunctionsAsVarInScope(scope) && (type & 1) > 0;
			return (type & 2) > 0 && !(scope.flags & 8 && scope.firstLexicalName === name) || !this.treatFunctionsAsVarInScope(scope) && (type & 4) > 0;
		}
		checkLocalExport(id) {
			const { name } = id;
			if (!this.scopeStack[0].names.has(name)) this.undefinedExports.set(name, id.loc.start);
		}
		currentScope() {
			return this.scopeStack[this.scopeStack.length - 1];
		}
		currentVarScopeFlags() {
			for (let i = this.scopeStack.length - 1;; i--) {
				const { flags } = this.scopeStack[i];
				if (flags & 1667) return flags;
			}
		}
		currentThisScopeFlags() {
			for (let i = this.scopeStack.length - 1;; i--) {
				const { flags } = this.scopeStack[i];
				if (flags & 1731 && !(flags & 4)) return flags;
			}
		}
	};
	var FlowScope = class extends Scope {
		constructor(...args) {
			super(...args);
			this.declareFunctions = /* @__PURE__ */ new Set();
		}
	};
	var FlowScopeHandler = class extends ScopeHandler {
		createScope(flags) {
			return new FlowScope(flags);
		}
		declareName(name, bindingType, loc) {
			const scope = this.currentScope();
			if (bindingType & 2048) {
				this.checkRedeclarationInScope(scope, name, bindingType, loc);
				this.maybeExportDefined(scope, name);
				scope.declareFunctions.add(name);
				return;
			}
			super.declareName(name, bindingType, loc);
		}
		isRedeclaredInScope(scope, name, bindingType) {
			if (super.isRedeclaredInScope(scope, name, bindingType)) return true;
			if (bindingType & 2048 && !scope.declareFunctions.has(name)) {
				const type = scope.names.get(name);
				return (type & 4) > 0 || (type & 2) > 0;
			}
			return false;
		}
		checkLocalExport(id) {
			if (!this.scopeStack[0].declareFunctions.has(id.name)) super.checkLocalExport(id);
		}
	};
	const reservedTypes = /* @__PURE__ */ new Set([
		"_",
		"any",
		"bool",
		"boolean",
		"empty",
		"extends",
		"false",
		"interface",
		"mixed",
		"null",
		"number",
		"static",
		"string",
		"true",
		"typeof",
		"void"
	]);
	const FlowErrors = ParseErrorEnum`flow`({
		AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
		AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
		AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`,
		DeclareClassElement: "The `declare` modifier can only appear on class fields.",
		DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
		DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
		EnumBooleanMemberNotInitialized: ({ memberName, enumName }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
		EnumDuplicateMemberName: ({ memberName, enumName }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
		EnumInconsistentMemberValues: ({ enumName }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
		EnumInvalidExplicitType: ({ invalidEnumType, enumName }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
		EnumInvalidExplicitTypeUnknownSupplied: ({ enumName }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
		EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
		EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
		EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
		EnumInvalidMemberName: ({ enumName, memberName, suggestion }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
		EnumNumberMemberNotInitialized: ({ enumName, memberName }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
		EnumStringMemberInconsistentlyInitialized: ({ enumName }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
		GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
		ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.",
		ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
		InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
		InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
		InexactVariance: "Explicit inexact syntax cannot have variance.",
		InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
		MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
		NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
		NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
		PatternIsOptional: Object.assign({ message: "A binding pattern parameter cannot be optional in an implementation signature." }, { reasonCode: "OptionalBindingPattern" }),
		SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
		SpreadVariance: "Spread properties cannot have variance.",
		ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
		ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
		ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
		ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
		ThisParamNoDefault: "The `this` parameter may not have a default value.",
		TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
		TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
		UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
		UnexpectedReservedType: ({ reservedType }) => `Unexpected reserved type ${reservedType}.`,
		UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
		UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
		UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
		UnexpectedSubtractionOperand: "Unexpected token, expected \"number\" or \"bigint\".",
		UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
		UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
		UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
		UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
		UnterminatedFlowComment: "Unterminated flow-comment."
	});
	function isEsModuleType(bodyElement) {
		return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
	}
	function hasTypeImportKind(node) {
		return node.importKind === "type" || node.importKind === "typeof";
	}
	const exportSuggestions = {
		const: "declare export var",
		let: "declare export var",
		type: "export type",
		interface: "export interface"
	};
	function partition(list, test) {
		const list1 = [];
		const list2 = [];
		for (let i = 0; i < list.length; i++) (test(list[i], i, list) ? list1 : list2).push(list[i]);
		return [list1, list2];
	}
	const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
	var flow = (superClass) => class FlowParserMixin extends superClass {
		constructor(...args) {
			super(...args);
			this.flowPragma = void 0;
		}
		getScopeHandler() {
			return FlowScopeHandler;
		}
		shouldParseTypes() {
			return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
		}
		finishToken(type, val) {
			if (type !== 134 && type !== 13 && type !== 28) {
				if (this.flowPragma === void 0) this.flowPragma = null;
			}
			super.finishToken(type, val);
		}
		addComment(comment) {
			if (this.flowPragma === void 0) {
				const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
				if (!matches);
				else if (matches[1] === "flow") this.flowPragma = "flow";
				else if (matches[1] === "noflow") this.flowPragma = "noflow";
				else throw new Error("Unexpected flow pragma");
			}
			super.addComment(comment);
		}
		flowParseTypeInitialiser(tok) {
			const oldInType = this.state.inType;
			this.state.inType = true;
			this.expect(tok || 14);
			const type = this.flowParseType();
			this.state.inType = oldInType;
			return type;
		}
		flowParsePredicate() {
			const node = this.startNode();
			const moduloLoc = this.state.startLoc;
			this.next();
			this.expectContextual(110);
			if (this.state.lastTokStartLoc.index > moduloLoc.index + 1) this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, moduloLoc);
			if (this.eat(10)) {
				node.value = super.parseExpression();
				this.expect(11);
				return this.finishNode(node, "DeclaredPredicate");
			} else return this.finishNode(node, "InferredPredicate");
		}
		flowParseTypeAndPredicateInitialiser() {
			const oldInType = this.state.inType;
			this.state.inType = true;
			this.expect(14);
			let type = null;
			let predicate = null;
			if (this.match(54)) {
				this.state.inType = oldInType;
				predicate = this.flowParsePredicate();
			} else {
				type = this.flowParseType();
				this.state.inType = oldInType;
				if (this.match(54)) predicate = this.flowParsePredicate();
			}
			return [type, predicate];
		}
		flowParseDeclareClass(node) {
			this.next();
			this.flowParseInterfaceish(node, true);
			return this.finishNode(node, "DeclareClass");
		}
		flowParseDeclareFunction(node) {
			this.next();
			const id = node.id = this.parseIdentifier();
			const typeNode = this.startNode();
			const typeContainer = this.startNode();
			if (this.match(47)) typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
			else typeNode.typeParameters = null;
			this.expect(10);
			const tmp = this.flowParseFunctionTypeParams();
			typeNode.params = tmp.params;
			typeNode.rest = tmp.rest;
			typeNode.this = tmp._this;
			this.expect(11);
			[typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
			typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
			id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
			this.resetEndLocation(id);
			this.semicolon();
			this.scope.declareName(node.id.name, 2048, node.id.loc.start);
			return this.finishNode(node, "DeclareFunction");
		}
		flowParseDeclare(node, insideModule) {
			if (this.match(80)) return this.flowParseDeclareClass(node);
			else if (this.match(68)) return this.flowParseDeclareFunction(node);
			else if (this.match(74)) return this.flowParseDeclareVariable(node);
			else if (this.eatContextual(127)) {
				if (this.match(16)) return this.flowParseDeclareModuleExports(node);
				else {
					if (insideModule) this.raise(FlowErrors.NestedDeclareModule, this.state.lastTokStartLoc);
					return this.flowParseDeclareModule(node);
				}
			} else if (this.isContextual(130)) return this.flowParseDeclareTypeAlias(node);
			else if (this.isContextual(131)) return this.flowParseDeclareOpaqueType(node);
			else if (this.isContextual(129)) return this.flowParseDeclareInterface(node);
			else if (this.match(82)) return this.flowParseDeclareExportDeclaration(node, insideModule);
			throw this.unexpected();
		}
		flowParseDeclareVariable(node) {
			this.next();
			node.id = this.flowParseTypeAnnotatableIdentifier();
			this.scope.declareName(node.id.name, 5, node.id.loc.start);
			this.semicolon();
			return this.finishNode(node, "DeclareVariable");
		}
		flowParseDeclareModule(node) {
			this.scope.enter(0);
			if (this.match(134)) node.id = super.parseExprAtom();
			else node.id = this.parseIdentifier();
			const bodyNode = node.body = this.startNode();
			const body = bodyNode.body = [];
			this.expect(5);
			while (!this.match(8)) {
				const bodyNode = this.startNode();
				if (this.match(83)) {
					this.next();
					if (!this.isContextual(130) && !this.match(87)) this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, this.state.lastTokStartLoc);
					body.push(super.parseImport(bodyNode));
				} else {
					this.expectContextual(125, FlowErrors.UnsupportedStatementInDeclareModule);
					body.push(this.flowParseDeclare(bodyNode, true));
				}
			}
			this.scope.exit();
			this.expect(8);
			this.finishNode(bodyNode, "BlockStatement");
			let kind = null;
			let hasModuleExport = false;
			body.forEach((bodyElement) => {
				if (isEsModuleType(bodyElement)) {
					if (kind === "CommonJS") this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
					kind = "ES";
				} else if (bodyElement.type === "DeclareModuleExports") {
					if (hasModuleExport) this.raise(FlowErrors.DuplicateDeclareModuleExports, bodyElement);
					if (kind === "ES") this.raise(FlowErrors.AmbiguousDeclareModuleKind, bodyElement);
					kind = "CommonJS";
					hasModuleExport = true;
				}
			});
			node.kind = kind || "CommonJS";
			return this.finishNode(node, "DeclareModule");
		}
		flowParseDeclareExportDeclaration(node, insideModule) {
			this.expect(82);
			if (this.eat(65)) {
				if (this.match(68) || this.match(80)) node.declaration = this.flowParseDeclare(this.startNode());
				else {
					node.declaration = this.flowParseType();
					this.semicolon();
				}
				node.default = true;
				return this.finishNode(node, "DeclareExportDeclaration");
			} else {
				if (this.match(75) || this.isLet() || (this.isContextual(130) || this.isContextual(129)) && !insideModule) {
					const label = this.state.value;
					throw this.raise(FlowErrors.UnsupportedDeclareExportKind, this.state.startLoc, {
						unsupportedExportKind: label,
						suggestion: exportSuggestions[label]
					});
				}
				if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(131)) {
					node.declaration = this.flowParseDeclare(this.startNode());
					node.default = false;
					return this.finishNode(node, "DeclareExportDeclaration");
				} else if (this.match(55) || this.match(5) || this.isContextual(129) || this.isContextual(130) || this.isContextual(131)) {
					node = this.parseExport(node, null);
					if (node.type === "ExportNamedDeclaration") {
						node.default = false;
						delete node.exportKind;
						return this.castNodeTo(node, "DeclareExportDeclaration");
					} else return this.castNodeTo(node, "DeclareExportAllDeclaration");
				}
			}
			throw this.unexpected();
		}
		flowParseDeclareModuleExports(node) {
			this.next();
			this.expectContextual(111);
			node.typeAnnotation = this.flowParseTypeAnnotation();
			this.semicolon();
			return this.finishNode(node, "DeclareModuleExports");
		}
		flowParseDeclareTypeAlias(node) {
			this.next();
			const finished = this.flowParseTypeAlias(node);
			this.castNodeTo(finished, "DeclareTypeAlias");
			return finished;
		}
		flowParseDeclareOpaqueType(node) {
			this.next();
			const finished = this.flowParseOpaqueType(node, true);
			this.castNodeTo(finished, "DeclareOpaqueType");
			return finished;
		}
		flowParseDeclareInterface(node) {
			this.next();
			this.flowParseInterfaceish(node, false);
			return this.finishNode(node, "DeclareInterface");
		}
		flowParseInterfaceish(node, isClass) {
			node.id = this.flowParseRestrictedIdentifier(!isClass, true);
			this.scope.declareName(node.id.name, isClass ? 17 : 8201, node.id.loc.start);
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterDeclaration();
			else node.typeParameters = null;
			node.extends = [];
			if (this.eat(81)) do
				node.extends.push(this.flowParseInterfaceExtends());
			while (!isClass && this.eat(12));
			if (isClass) {
				node.implements = [];
				node.mixins = [];
				if (this.eatContextual(117)) do
					node.mixins.push(this.flowParseInterfaceExtends());
				while (this.eat(12));
				if (this.eatContextual(113)) do
					node.implements.push(this.flowParseInterfaceExtends());
				while (this.eat(12));
			}
			node.body = this.flowParseObjectType({
				allowStatic: isClass,
				allowExact: false,
				allowSpread: false,
				allowProto: isClass,
				allowInexact: false
			});
		}
		flowParseInterfaceExtends() {
			const node = this.startNode();
			node.id = this.flowParseQualifiedTypeIdentifier();
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterInstantiation();
			else node.typeParameters = null;
			return this.finishNode(node, "InterfaceExtends");
		}
		flowParseInterface(node) {
			this.flowParseInterfaceish(node, false);
			return this.finishNode(node, "InterfaceDeclaration");
		}
		checkNotUnderscore(word) {
			if (word === "_") this.raise(FlowErrors.UnexpectedReservedUnderscore, this.state.startLoc);
		}
		checkReservedType(word, startLoc, declaration) {
			if (!reservedTypes.has(word)) return;
			this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, startLoc, { reservedType: word });
		}
		flowParseRestrictedIdentifierName(liberal, declaration) {
			this.checkReservedType(this.state.value, this.state.startLoc, declaration);
			return this.parseIdentifierName(liberal);
		}
		flowParseRestrictedIdentifier(liberal, declaration) {
			const node = this.startNode();
			const name = this.flowParseRestrictedIdentifierName(liberal, declaration);
			return this.createIdentifier(node, name);
		}
		flowParseTypeAlias(node) {
			node.id = this.flowParseRestrictedIdentifier(false, true);
			this.scope.declareName(node.id.name, 8201, node.id.loc.start);
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterDeclaration();
			else node.typeParameters = null;
			node.right = this.flowParseTypeInitialiser(29);
			this.semicolon();
			return this.finishNode(node, "TypeAlias");
		}
		flowParseOpaqueType(node, declare) {
			this.expectContextual(130);
			node.id = this.flowParseRestrictedIdentifier(true, true);
			this.scope.declareName(node.id.name, 8201, node.id.loc.start);
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterDeclaration();
			else node.typeParameters = null;
			node.supertype = null;
			if (this.match(14)) node.supertype = this.flowParseTypeInitialiser(14);
			node.impltype = null;
			if (!declare) node.impltype = this.flowParseTypeInitialiser(29);
			this.semicolon();
			return this.finishNode(node, "OpaqueType");
		}
		flowParseTypeParameterBound() {
			if (this.match(14) || this.isContextual(81)) {
				const node = this.startNode();
				this.next();
				node.typeAnnotation = this.flowParseType();
				return this.finishNode(node, "TypeAnnotation");
			}
		}
		flowParseTypeParameter(requireDefault = false) {
			const nodeStartLoc = this.state.startLoc;
			const node = this.startNode();
			const variance = this.flowParseVariance();
			node.name = this.flowParseRestrictedIdentifierName();
			node.variance = variance;
			node.bound = this.flowParseTypeParameterBound();
			if (this.match(29)) {
				this.eat(29);
				node.default = this.flowParseType();
			} else if (requireDefault) this.raise(FlowErrors.MissingTypeParamDefault, nodeStartLoc);
			return this.finishNode(node, "TypeParameter");
		}
		flowParseTypeParameterDeclaration() {
			const oldInType = this.state.inType;
			const node = this.startNode();
			node.params = [];
			this.state.inType = true;
			if (this.match(47) || this.match(143)) this.next();
			else this.unexpected();
			let defaultRequired = false;
			do {
				const typeParameter = this.flowParseTypeParameter(defaultRequired);
				node.params.push(typeParameter);
				if (typeParameter.default) defaultRequired = true;
				if (!this.match(48)) this.expect(12);
			} while (!this.match(48));
			this.expect(48);
			this.state.inType = oldInType;
			return this.finishNode(node, "TypeParameterDeclaration");
		}
		flowInTopLevelContext(cb) {
			if (this.curContext() !== types.brace) {
				const oldContext = this.state.context;
				this.state.context = [oldContext[0]];
				try {
					return cb();
				} finally {
					this.state.context = oldContext;
				}
			} else return cb();
		}
		flowParseTypeParameterInstantiationInExpression() {
			if (this.reScan_lt() !== 47) return;
			return this.flowParseTypeParameterInstantiation();
		}
		flowParseTypeParameterInstantiation() {
			const node = this.startNode();
			const oldInType = this.state.inType;
			this.state.inType = true;
			node.params = [];
			this.flowInTopLevelContext(() => {
				this.expect(47);
				const oldNoAnonFunctionType = this.state.noAnonFunctionType;
				this.state.noAnonFunctionType = false;
				while (!this.match(48)) {
					node.params.push(this.flowParseType());
					if (!this.match(48)) this.expect(12);
				}
				this.state.noAnonFunctionType = oldNoAnonFunctionType;
			});
			this.state.inType = oldInType;
			if (!this.state.inType && this.curContext() === types.brace) this.reScan_lt_gt();
			this.expect(48);
			return this.finishNode(node, "TypeParameterInstantiation");
		}
		flowParseTypeParameterInstantiationCallOrNew() {
			if (this.reScan_lt() !== 47) return null;
			const node = this.startNode();
			const oldInType = this.state.inType;
			node.params = [];
			this.state.inType = true;
			this.expect(47);
			while (!this.match(48)) {
				node.params.push(this.flowParseTypeOrImplicitInstantiation());
				if (!this.match(48)) this.expect(12);
			}
			this.expect(48);
			this.state.inType = oldInType;
			return this.finishNode(node, "TypeParameterInstantiation");
		}
		flowParseInterfaceType() {
			const node = this.startNode();
			this.expectContextual(129);
			node.extends = [];
			if (this.eat(81)) do
				node.extends.push(this.flowParseInterfaceExtends());
			while (this.eat(12));
			node.body = this.flowParseObjectType({
				allowStatic: false,
				allowExact: false,
				allowSpread: false,
				allowProto: false,
				allowInexact: false
			});
			return this.finishNode(node, "InterfaceTypeAnnotation");
		}
		flowParseObjectPropertyKey() {
			return this.match(135) || this.match(134) ? super.parseExprAtom() : this.parseIdentifier(true);
		}
		flowParseObjectTypeIndexer(node, isStatic, variance) {
			node.static = isStatic;
			if (this.lookahead().type === 14) {
				node.id = this.flowParseObjectPropertyKey();
				node.key = this.flowParseTypeInitialiser();
			} else {
				node.id = null;
				node.key = this.flowParseType();
			}
			this.expect(3);
			node.value = this.flowParseTypeInitialiser();
			node.variance = variance;
			return this.finishNode(node, "ObjectTypeIndexer");
		}
		flowParseObjectTypeInternalSlot(node, isStatic) {
			node.static = isStatic;
			node.id = this.flowParseObjectPropertyKey();
			this.expect(3);
			this.expect(3);
			if (this.match(47) || this.match(10)) {
				node.method = true;
				node.optional = false;
				node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
			} else {
				node.method = false;
				if (this.eat(17)) node.optional = true;
				node.value = this.flowParseTypeInitialiser();
			}
			return this.finishNode(node, "ObjectTypeInternalSlot");
		}
		flowParseObjectTypeMethodish(node) {
			node.params = [];
			node.rest = null;
			node.typeParameters = null;
			node.this = null;
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterDeclaration();
			this.expect(10);
			if (this.match(78)) {
				node.this = this.flowParseFunctionTypeParam(true);
				node.this.name = null;
				if (!this.match(11)) this.expect(12);
			}
			while (!this.match(11) && !this.match(21)) {
				node.params.push(this.flowParseFunctionTypeParam(false));
				if (!this.match(11)) this.expect(12);
			}
			if (this.eat(21)) node.rest = this.flowParseFunctionTypeParam(false);
			this.expect(11);
			node.returnType = this.flowParseTypeInitialiser();
			return this.finishNode(node, "FunctionTypeAnnotation");
		}
		flowParseObjectTypeCallProperty(node, isStatic) {
			const valueNode = this.startNode();
			node.static = isStatic;
			node.value = this.flowParseObjectTypeMethodish(valueNode);
			return this.finishNode(node, "ObjectTypeCallProperty");
		}
		flowParseObjectType({ allowStatic, allowExact, allowSpread, allowProto, allowInexact }) {
			const oldInType = this.state.inType;
			this.state.inType = true;
			const nodeStart = this.startNode();
			nodeStart.callProperties = [];
			nodeStart.properties = [];
			nodeStart.indexers = [];
			nodeStart.internalSlots = [];
			let endDelim;
			let exact;
			let inexact = false;
			if (allowExact && this.match(6)) {
				this.expect(6);
				endDelim = 9;
				exact = true;
			} else {
				this.expect(5);
				endDelim = 8;
				exact = false;
			}
			nodeStart.exact = exact;
			while (!this.match(endDelim)) {
				let isStatic = false;
				let protoStartLoc = null;
				let inexactStartLoc = null;
				const node = this.startNode();
				if (allowProto && this.isContextual(118)) {
					const lookahead = this.lookahead();
					if (lookahead.type !== 14 && lookahead.type !== 17) {
						this.next();
						protoStartLoc = this.state.startLoc;
						allowStatic = false;
					}
				}
				if (allowStatic && this.isContextual(106)) {
					const lookahead = this.lookahead();
					if (lookahead.type !== 14 && lookahead.type !== 17) {
						this.next();
						isStatic = true;
					}
				}
				const variance = this.flowParseVariance();
				if (this.eat(0)) {
					if (protoStartLoc != null) this.unexpected(protoStartLoc);
					if (this.eat(0)) {
						if (variance) this.unexpected(variance.loc.start);
						nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
					} else nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
				} else if (this.match(10) || this.match(47)) {
					if (protoStartLoc != null) this.unexpected(protoStartLoc);
					if (variance) this.unexpected(variance.loc.start);
					nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
				} else {
					let kind = "init";
					if (this.isContextual(99) || this.isContextual(104)) {
						if (tokenIsLiteralPropertyName(this.lookahead().type)) {
							kind = this.state.value;
							this.next();
						}
					}
					const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
					if (propOrInexact === null) {
						inexact = true;
						inexactStartLoc = this.state.lastTokStartLoc;
					} else nodeStart.properties.push(propOrInexact);
				}
				this.flowObjectTypeSemicolon();
				if (inexactStartLoc && !this.match(8) && !this.match(9)) this.raise(FlowErrors.UnexpectedExplicitInexactInObject, inexactStartLoc);
			}
			this.expect(endDelim);
			if (allowSpread) nodeStart.inexact = inexact;
			const out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
			this.state.inType = oldInType;
			return out;
		}
		flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
			if (this.eat(21)) {
				if (this.match(12) || this.match(13) || this.match(8) || this.match(9)) {
					if (!allowSpread) this.raise(FlowErrors.InexactInsideNonObject, this.state.lastTokStartLoc);
					else if (!allowInexact) this.raise(FlowErrors.InexactInsideExact, this.state.lastTokStartLoc);
					if (variance) this.raise(FlowErrors.InexactVariance, variance);
					return null;
				}
				if (!allowSpread) this.raise(FlowErrors.UnexpectedSpreadType, this.state.lastTokStartLoc);
				if (protoStartLoc != null) this.unexpected(protoStartLoc);
				if (variance) this.raise(FlowErrors.SpreadVariance, variance);
				node.argument = this.flowParseType();
				return this.finishNode(node, "ObjectTypeSpreadProperty");
			} else {
				node.key = this.flowParseObjectPropertyKey();
				node.static = isStatic;
				node.proto = protoStartLoc != null;
				node.kind = kind;
				let optional = false;
				if (this.match(47) || this.match(10)) {
					node.method = true;
					if (protoStartLoc != null) this.unexpected(protoStartLoc);
					if (variance) this.unexpected(variance.loc.start);
					node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
					if (kind === "get" || kind === "set") this.flowCheckGetterSetterParams(node);
					if (!allowSpread && node.key.name === "constructor" && node.value.this) this.raise(FlowErrors.ThisParamBannedInConstructor, node.value.this);
				} else {
					if (kind !== "init") this.unexpected();
					node.method = false;
					if (this.eat(17)) optional = true;
					node.value = this.flowParseTypeInitialiser();
					node.variance = variance;
				}
				node.optional = optional;
				return this.finishNode(node, "ObjectTypeProperty");
			}
		}
		flowCheckGetterSetterParams(property) {
			const paramCount = property.kind === "get" ? 0 : 1;
			const length = property.value.params.length + (property.value.rest ? 1 : 0);
			if (property.value.this) this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, property.value.this);
			if (length !== paramCount) this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, property);
			if (property.kind === "set" && property.value.rest) this.raise(Errors.BadSetterRestParameter, property);
		}
		flowObjectTypeSemicolon() {
			if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) this.unexpected();
		}
		flowParseQualifiedTypeIdentifier(startLoc, id) {
			startLoc != null || (startLoc = this.state.startLoc);
			let node = id || this.flowParseRestrictedIdentifier(true);
			while (this.eat(16)) {
				const node2 = this.startNodeAt(startLoc);
				node2.qualification = node;
				node2.id = this.flowParseRestrictedIdentifier(true);
				node = this.finishNode(node2, "QualifiedTypeIdentifier");
			}
			return node;
		}
		flowParseGenericType(startLoc, id) {
			const node = this.startNodeAt(startLoc);
			node.typeParameters = null;
			node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterInstantiation();
			return this.finishNode(node, "GenericTypeAnnotation");
		}
		flowParseTypeofType() {
			const node = this.startNode();
			this.expect(87);
			node.argument = this.flowParsePrimaryType();
			return this.finishNode(node, "TypeofTypeAnnotation");
		}
		flowParseTupleType() {
			const node = this.startNode();
			node.types = [];
			this.expect(0);
			while (this.state.pos < this.length && !this.match(3)) {
				node.types.push(this.flowParseType());
				if (this.match(3)) break;
				this.expect(12);
			}
			this.expect(3);
			return this.finishNode(node, "TupleTypeAnnotation");
		}
		flowParseFunctionTypeParam(first) {
			let name = null;
			let optional = false;
			let typeAnnotation = null;
			const node = this.startNode();
			const lh = this.lookahead();
			const isThis = this.state.type === 78;
			if (lh.type === 14 || lh.type === 17) {
				if (isThis && !first) this.raise(FlowErrors.ThisParamMustBeFirst, node);
				name = this.parseIdentifier(isThis);
				if (this.eat(17)) {
					optional = true;
					if (isThis) this.raise(FlowErrors.ThisParamMayNotBeOptional, node);
				}
				typeAnnotation = this.flowParseTypeInitialiser();
			} else typeAnnotation = this.flowParseType();
			node.name = name;
			node.optional = optional;
			node.typeAnnotation = typeAnnotation;
			return this.finishNode(node, "FunctionTypeParam");
		}
		reinterpretTypeAsFunctionTypeParam(type) {
			const node = this.startNodeAt(type.loc.start);
			node.name = null;
			node.optional = false;
			node.typeAnnotation = type;
			return this.finishNode(node, "FunctionTypeParam");
		}
		flowParseFunctionTypeParams(params = []) {
			let rest = null;
			let _this = null;
			if (this.match(78)) {
				_this = this.flowParseFunctionTypeParam(true);
				_this.name = null;
				if (!this.match(11)) this.expect(12);
			}
			while (!this.match(11) && !this.match(21)) {
				params.push(this.flowParseFunctionTypeParam(false));
				if (!this.match(11)) this.expect(12);
			}
			if (this.eat(21)) rest = this.flowParseFunctionTypeParam(false);
			return {
				params,
				rest,
				_this
			};
		}
		flowIdentToTypeAnnotation(startLoc, node, id) {
			switch (id.name) {
				case "any": return this.finishNode(node, "AnyTypeAnnotation");
				case "bool":
				case "boolean": return this.finishNode(node, "BooleanTypeAnnotation");
				case "mixed": return this.finishNode(node, "MixedTypeAnnotation");
				case "empty": return this.finishNode(node, "EmptyTypeAnnotation");
				case "number": return this.finishNode(node, "NumberTypeAnnotation");
				case "string": return this.finishNode(node, "StringTypeAnnotation");
				case "symbol": return this.finishNode(node, "SymbolTypeAnnotation");
				default:
					this.checkNotUnderscore(id.name);
					return this.flowParseGenericType(startLoc, id);
			}
		}
		flowParsePrimaryType() {
			const startLoc = this.state.startLoc;
			const node = this.startNode();
			let tmp;
			let type;
			let isGroupedType = false;
			const oldNoAnonFunctionType = this.state.noAnonFunctionType;
			switch (this.state.type) {
				case 5: return this.flowParseObjectType({
					allowStatic: false,
					allowExact: false,
					allowSpread: true,
					allowProto: false,
					allowInexact: true
				});
				case 6: return this.flowParseObjectType({
					allowStatic: false,
					allowExact: true,
					allowSpread: true,
					allowProto: false,
					allowInexact: false
				});
				case 0:
					this.state.noAnonFunctionType = false;
					type = this.flowParseTupleType();
					this.state.noAnonFunctionType = oldNoAnonFunctionType;
					return type;
				case 47: {
					const node = this.startNode();
					node.typeParameters = this.flowParseTypeParameterDeclaration();
					this.expect(10);
					tmp = this.flowParseFunctionTypeParams();
					node.params = tmp.params;
					node.rest = tmp.rest;
					node.this = tmp._this;
					this.expect(11);
					this.expect(19);
					node.returnType = this.flowParseType();
					return this.finishNode(node, "FunctionTypeAnnotation");
				}
				case 10: {
					const node = this.startNode();
					this.next();
					if (!this.match(11) && !this.match(21)) {
						if (tokenIsIdentifier(this.state.type) || this.match(78)) {
							const token = this.lookahead().type;
							isGroupedType = token !== 17 && token !== 14;
						} else isGroupedType = true;
					}
					if (isGroupedType) {
						this.state.noAnonFunctionType = false;
						type = this.flowParseType();
						this.state.noAnonFunctionType = oldNoAnonFunctionType;
						if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
							this.expect(11);
							return type;
						} else this.eat(12);
					}
					if (type) tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
					else tmp = this.flowParseFunctionTypeParams();
					node.params = tmp.params;
					node.rest = tmp.rest;
					node.this = tmp._this;
					this.expect(11);
					this.expect(19);
					node.returnType = this.flowParseType();
					node.typeParameters = null;
					return this.finishNode(node, "FunctionTypeAnnotation");
				}
				case 134: return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
				case 85:
				case 86:
					node.value = this.match(85);
					this.next();
					return this.finishNode(node, "BooleanLiteralTypeAnnotation");
				case 53:
					if (this.state.value === "-") {
						this.next();
						if (this.match(135)) return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
						if (this.match(136)) return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
						throw this.raise(FlowErrors.UnexpectedSubtractionOperand, this.state.startLoc);
					}
					throw this.unexpected();
				case 135: return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
				case 136: return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
				case 88:
					this.next();
					return this.finishNode(node, "VoidTypeAnnotation");
				case 84:
					this.next();
					return this.finishNode(node, "NullLiteralTypeAnnotation");
				case 78:
					this.next();
					return this.finishNode(node, "ThisTypeAnnotation");
				case 55:
					this.next();
					return this.finishNode(node, "ExistsTypeAnnotation");
				case 87: return this.flowParseTypeofType();
				default: if (tokenIsKeyword(this.state.type)) {
					const label = tokenLabelName(this.state.type);
					this.next();
					return super.createIdentifier(node, label);
				} else if (tokenIsIdentifier(this.state.type)) {
					if (this.isContextual(129)) return this.flowParseInterfaceType();
					return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
				}
			}
			throw this.unexpected();
		}
		flowParsePostfixType() {
			const startLoc = this.state.startLoc;
			let type = this.flowParsePrimaryType();
			let seenOptionalIndexedAccess = false;
			while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
				const node = this.startNodeAt(startLoc);
				const optional = this.eat(18);
				seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
				this.expect(0);
				if (!optional && this.match(3)) {
					node.elementType = type;
					this.next();
					type = this.finishNode(node, "ArrayTypeAnnotation");
				} else {
					node.objectType = type;
					node.indexType = this.flowParseType();
					this.expect(3);
					if (seenOptionalIndexedAccess) {
						node.optional = optional;
						type = this.finishNode(node, "OptionalIndexedAccessType");
					} else type = this.finishNode(node, "IndexedAccessType");
				}
			}
			return type;
		}
		flowParsePrefixType() {
			const node = this.startNode();
			if (this.eat(17)) {
				node.typeAnnotation = this.flowParsePrefixType();
				return this.finishNode(node, "NullableTypeAnnotation");
			} else return this.flowParsePostfixType();
		}
		flowParseAnonFunctionWithoutParens() {
			const param = this.flowParsePrefixType();
			if (!this.state.noAnonFunctionType && this.eat(19)) {
				const node = this.startNodeAt(param.loc.start);
				node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
				node.rest = null;
				node.this = null;
				node.returnType = this.flowParseType();
				node.typeParameters = null;
				return this.finishNode(node, "FunctionTypeAnnotation");
			}
			return param;
		}
		flowParseIntersectionType() {
			const node = this.startNode();
			this.eat(45);
			const type = this.flowParseAnonFunctionWithoutParens();
			node.types = [type];
			while (this.eat(45)) node.types.push(this.flowParseAnonFunctionWithoutParens());
			return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation");
		}
		flowParseUnionType() {
			const node = this.startNode();
			this.eat(43);
			const type = this.flowParseIntersectionType();
			node.types = [type];
			while (this.eat(43)) node.types.push(this.flowParseIntersectionType());
			return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation");
		}
		flowParseType() {
			const oldInType = this.state.inType;
			this.state.inType = true;
			const type = this.flowParseUnionType();
			this.state.inType = oldInType;
			return type;
		}
		flowParseTypeOrImplicitInstantiation() {
			if (this.state.type === 132 && this.state.value === "_") {
				const startLoc = this.state.startLoc;
				const node = this.parseIdentifier();
				return this.flowParseGenericType(startLoc, node);
			} else return this.flowParseType();
		}
		flowParseTypeAnnotation() {
			const node = this.startNode();
			node.typeAnnotation = this.flowParseTypeInitialiser();
			return this.finishNode(node, "TypeAnnotation");
		}
		flowParseTypeAnnotatableIdentifier() {
			const node = this.startNode();
			const name = this.parseIdentifierName();
			if (this.match(14)) node.typeAnnotation = this.flowParseTypeAnnotation();
			return this.createIdentifier(node, name);
		}
		typeCastToParameter(node) {
			node.expression.typeAnnotation = node.typeAnnotation;
			this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
			return node.expression;
		}
		flowParseVariance() {
			let variance = null;
			if (this.match(53)) {
				variance = this.startNode();
				if (this.state.value === "+") variance.kind = "plus";
				else variance.kind = "minus";
				this.next();
				return this.finishNode(variance, "Variance");
			}
			return variance;
		}
		parseFunctionBody(node, allowExpressionBody, isMethod = false) {
			if (allowExpressionBody) {
				this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));
				return;
			}
			super.parseFunctionBody(node, false, isMethod);
		}
		parseFunctionBodyAndFinish(node, type, isMethod = false) {
			if (this.match(14)) {
				const typeNode = this.startNode();
				[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
				node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
			}
			return super.parseFunctionBodyAndFinish(node, type, isMethod);
		}
		parseStatementLike(flags) {
			if (this.state.strict && this.isContextual(129)) {
				if (tokenIsKeywordOrIdentifier(this.lookahead().type)) {
					const node = this.startNode();
					this.next();
					return this.flowParseInterface(node);
				}
			} else if (this.isContextual(126)) {
				const node = this.startNode();
				this.next();
				return this.flowParseEnumDeclaration(node);
			}
			const stmt = super.parseStatementLike(flags);
			if (this.flowPragma === void 0 && !this.isValidDirective(stmt)) this.flowPragma = null;
			return stmt;
		}
		parseExpressionStatement(node, expr, decorators) {
			if (expr.type === "Identifier") {
				if (expr.name === "declare") {
					if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) return this.flowParseDeclare(node);
				} else if (tokenIsIdentifier(this.state.type)) {
					if (expr.name === "interface") return this.flowParseInterface(node);
					else if (expr.name === "type") return this.flowParseTypeAlias(node);
					else if (expr.name === "opaque") return this.flowParseOpaqueType(node, false);
				}
			}
			return super.parseExpressionStatement(node, expr, decorators);
		}
		shouldParseExportDeclaration() {
			const { type } = this.state;
			if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) return !this.state.containsEsc;
			return super.shouldParseExportDeclaration();
		}
		isExportDefaultSpecifier() {
			const { type } = this.state;
			if (type === 126 || tokenIsFlowInterfaceOrTypeOrOpaque(type)) return this.state.containsEsc;
			return super.isExportDefaultSpecifier();
		}
		parseExportDefaultExpression() {
			if (this.isContextual(126)) {
				const node = this.startNode();
				this.next();
				return this.flowParseEnumDeclaration(node);
			}
			return super.parseExportDefaultExpression();
		}
		parseConditional(expr, startLoc, refExpressionErrors) {
			if (!this.match(17)) return expr;
			if (this.state.maybeInArrowParameters) {
				const nextCh = this.lookaheadCharCode();
				if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
					this.setOptionalParametersError(refExpressionErrors);
					return expr;
				}
			}
			this.expect(17);
			const state = this.state.clone();
			const originalNoArrowAt = this.state.noArrowAt;
			const node = this.startNodeAt(startLoc);
			let { consequent, failed } = this.tryParseConditionalConsequent();
			let [valid, invalid] = this.getArrowLikeExpressions(consequent);
			if (failed || invalid.length > 0) {
				const noArrowAt = [...originalNoArrowAt];
				if (invalid.length > 0) {
					this.state = state;
					this.state.noArrowAt = noArrowAt;
					for (let i = 0; i < invalid.length; i++) noArrowAt.push(invalid[i].start);
					({consequent, failed} = this.tryParseConditionalConsequent());
					[valid, invalid] = this.getArrowLikeExpressions(consequent);
				}
				if (failed && valid.length > 1) this.raise(FlowErrors.AmbiguousConditionalArrow, state.startLoc);
				if (failed && valid.length === 1) {
					this.state = state;
					noArrowAt.push(valid[0].start);
					this.state.noArrowAt = noArrowAt;
					({consequent, failed} = this.tryParseConditionalConsequent());
				}
			}
			this.getArrowLikeExpressions(consequent, true);
			this.state.noArrowAt = originalNoArrowAt;
			this.expect(14);
			node.test = expr;
			node.consequent = consequent;
			node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(void 0, void 0));
			return this.finishNode(node, "ConditionalExpression");
		}
		tryParseConditionalConsequent() {
			this.state.noArrowParamsConversionAt.push(this.state.start);
			const consequent = this.parseMaybeAssignAllowIn();
			const failed = !this.match(14);
			this.state.noArrowParamsConversionAt.pop();
			return {
				consequent,
				failed
			};
		}
		getArrowLikeExpressions(node, disallowInvalid) {
			const stack = [node];
			const arrows = [];
			while (stack.length !== 0) {
				const node = stack.pop();
				if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
					if (node.typeParameters || !node.returnType) this.finishArrowValidation(node);
					else arrows.push(node);
					stack.push(node.body);
				} else if (node.type === "ConditionalExpression") {
					stack.push(node.consequent);
					stack.push(node.alternate);
				}
			}
			if (disallowInvalid) {
				arrows.forEach((node) => this.finishArrowValidation(node));
				return [arrows, []];
			}
			return partition(arrows, (node) => node.params.every((param) => this.isAssignable(param, true)));
		}
		finishArrowValidation(node) {
			var _node$extra;
			this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
			this.scope.enter(518);
			super.checkParams(node, false, true);
			this.scope.exit();
		}
		forwardNoArrowParamsConversionAt(node, parse) {
			let result;
			if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
				this.state.noArrowParamsConversionAt.push(this.state.start);
				result = parse();
				this.state.noArrowParamsConversionAt.pop();
			} else result = parse();
			return result;
		}
		parseParenItem(node, startLoc) {
			const newNode = super.parseParenItem(node, startLoc);
			if (this.eat(17)) {
				newNode.optional = true;
				this.resetEndLocation(node);
			}
			if (this.match(14)) {
				const typeCastNode = this.startNodeAt(startLoc);
				typeCastNode.expression = newNode;
				typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
				return this.finishNode(typeCastNode, "TypeCastExpression");
			}
			return newNode;
		}
		assertModuleNodeAllowed(node) {
			if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") return;
			super.assertModuleNodeAllowed(node);
		}
		parseExportDeclaration(node) {
			if (this.isContextual(130)) {
				node.exportKind = "type";
				const declarationNode = this.startNode();
				this.next();
				if (this.match(5)) {
					node.specifiers = this.parseExportSpecifiers(true);
					super.parseExportFrom(node);
					return null;
				} else return this.flowParseTypeAlias(declarationNode);
			} else if (this.isContextual(131)) {
				node.exportKind = "type";
				const declarationNode = this.startNode();
				this.next();
				return this.flowParseOpaqueType(declarationNode, false);
			} else if (this.isContextual(129)) {
				node.exportKind = "type";
				const declarationNode = this.startNode();
				this.next();
				return this.flowParseInterface(declarationNode);
			} else if (this.isContextual(126)) {
				node.exportKind = "value";
				const declarationNode = this.startNode();
				this.next();
				return this.flowParseEnumDeclaration(declarationNode);
			} else return super.parseExportDeclaration(node);
		}
		eatExportStar(node) {
			if (super.eatExportStar(node)) return true;
			if (this.isContextual(130) && this.lookahead().type === 55) {
				node.exportKind = "type";
				this.next();
				this.next();
				return true;
			}
			return false;
		}
		maybeParseExportNamespaceSpecifier(node) {
			const { startLoc } = this.state;
			const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
			if (hasNamespace && node.exportKind === "type") this.unexpected(startLoc);
			return hasNamespace;
		}
		parseClassId(node, isStatement, optionalId) {
			super.parseClassId(node, isStatement, optionalId);
			if (this.match(47)) node.typeParameters = this.flowParseTypeParameterDeclaration();
		}
		parseClassMember(classBody, member, state) {
			const { startLoc } = this.state;
			if (this.isContextual(125)) {
				if (super.parseClassMemberFromModifier(classBody, member)) return;
				member.declare = true;
			}
			super.parseClassMember(classBody, member, state);
			if (member.declare) {
				if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") this.raise(FlowErrors.DeclareClassElement, startLoc);
				else if (member.value) this.raise(FlowErrors.DeclareClassFieldInitializer, member.value);
			}
		}
		isIterator(word) {
			return word === "iterator" || word === "asyncIterator";
		}
		readIterator() {
			const word = super.readWord1();
			const fullWord = "@@" + word;
			if (!this.isIterator(word) || !this.state.inType) this.raise(Errors.InvalidIdentifier, this.state.curPosition(), { identifierName: fullWord });
			this.finishToken(132, fullWord);
		}
		getTokenFromCode(code) {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (code === 123 && next === 124) this.finishOp(6, 2);
			else if (this.state.inType && (code === 62 || code === 60)) this.finishOp(code === 62 ? 48 : 47, 1);
			else if (this.state.inType && code === 63) {
				if (next === 46) this.finishOp(18, 2);
				else this.finishOp(17, 1);
			} else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {
				this.state.pos += 2;
				this.readIterator();
			} else super.getTokenFromCode(code);
		}
		isAssignable(node, isBinding) {
			if (node.type === "TypeCastExpression") return this.isAssignable(node.expression, isBinding);
			else return super.isAssignable(node, isBinding);
		}
		toAssignable(node, isLHS = false) {
			if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") node.left = this.typeCastToParameter(node.left);
			super.toAssignable(node, isLHS);
		}
		toAssignableList(exprList, trailingCommaLoc, isLHS) {
			for (let i = 0; i < exprList.length; i++) {
				const expr = exprList[i];
				if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") exprList[i] = this.typeCastToParameter(expr);
			}
			super.toAssignableList(exprList, trailingCommaLoc, isLHS);
		}
		toReferencedList(exprList, isParenthesizedExpr) {
			for (let i = 0; i < exprList.length; i++) {
				var _expr$extra;
				const expr = exprList[i];
				if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) this.raise(FlowErrors.TypeCastInPattern, expr.typeAnnotation);
			}
			return exprList;
		}
		parseArrayLike(close, isTuple, refExpressionErrors) {
			const node = super.parseArrayLike(close, isTuple, refExpressionErrors);
			if (refExpressionErrors != null && !this.state.maybeInArrowParameters) this.toReferencedList(node.elements);
			return node;
		}
		isValidLVal(type, disallowCallExpression, isParenthesized, binding) {
			return type === "TypeCastExpression" || super.isValidLVal(type, disallowCallExpression, isParenthesized, binding);
		}
		parseClassProperty(node) {
			if (this.match(14)) node.typeAnnotation = this.flowParseTypeAnnotation();
			return super.parseClassProperty(node);
		}
		parseClassPrivateProperty(node) {
			if (this.match(14)) node.typeAnnotation = this.flowParseTypeAnnotation();
			return super.parseClassPrivateProperty(node);
		}
		isClassMethod() {
			return this.match(47) || super.isClassMethod();
		}
		isClassProperty() {
			return this.match(14) || super.isClassProperty();
		}
		isNonstaticConstructor(method) {
			return !this.match(14) && super.isNonstaticConstructor(method);
		}
		pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
			if (method.variance) this.unexpected(method.variance.loc.start);
			delete method.variance;
			if (this.match(47)) method.typeParameters = this.flowParseTypeParameterDeclaration();
			super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
			if (method.params && isConstructor) {
				const params = method.params;
				if (params.length > 0 && this.isThisParam(params[0])) this.raise(FlowErrors.ThisParamBannedInConstructor, method);
			} else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
				const params = method.value.params;
				if (params.length > 0 && this.isThisParam(params[0])) this.raise(FlowErrors.ThisParamBannedInConstructor, method);
			}
		}
		pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
			if (method.variance) this.unexpected(method.variance.loc.start);
			delete method.variance;
			if (this.match(47)) method.typeParameters = this.flowParseTypeParameterDeclaration();
			super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
		}
		parseClassSuper(node) {
			super.parseClassSuper(node);
			if (node.superClass && (this.match(47) || this.match(51))) node.superTypeParameters = this.flowParseTypeParameterInstantiationInExpression();
			if (this.isContextual(113)) {
				this.next();
				const implemented = node.implements = [];
				do {
					const node = this.startNode();
					node.id = this.flowParseRestrictedIdentifier(true);
					if (this.match(47)) node.typeParameters = this.flowParseTypeParameterInstantiation();
					else node.typeParameters = null;
					implemented.push(this.finishNode(node, "ClassImplements"));
				} while (this.eat(12));
			}
		}
		checkGetterSetterParams(method) {
			super.checkGetterSetterParams(method);
			const params = this.getObjectOrClassMethodParams(method);
			if (params.length > 0) {
				const param = params[0];
				if (this.isThisParam(param) && method.kind === "get") this.raise(FlowErrors.GetterMayNotHaveThisParam, param);
				else if (this.isThisParam(param)) this.raise(FlowErrors.SetterMayNotHaveThisParam, param);
			}
		}
		parsePropertyNamePrefixOperator(node) {
			node.variance = this.flowParseVariance();
		}
		parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
			if (prop.variance) this.unexpected(prop.variance.loc.start);
			delete prop.variance;
			let typeParameters;
			if (this.match(47) && !isAccessor) {
				typeParameters = this.flowParseTypeParameterDeclaration();
				if (!this.match(10)) this.unexpected();
			}
			const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
			if (typeParameters) (result.value || result).typeParameters = typeParameters;
			return result;
		}
		parseFunctionParamType(param) {
			if (this.eat(17)) {
				if (param.type !== "Identifier") this.raise(FlowErrors.PatternIsOptional, param);
				if (this.isThisParam(param)) this.raise(FlowErrors.ThisParamMayNotBeOptional, param);
				param.optional = true;
			}
			if (this.match(14)) param.typeAnnotation = this.flowParseTypeAnnotation();
			else if (this.isThisParam(param)) this.raise(FlowErrors.ThisParamAnnotationRequired, param);
			if (this.match(29) && this.isThisParam(param)) this.raise(FlowErrors.ThisParamNoDefault, param);
			this.resetEndLocation(param);
			return param;
		}
		parseMaybeDefault(startLoc, left) {
			const node = super.parseMaybeDefault(startLoc, left);
			if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) this.raise(FlowErrors.TypeBeforeInitializer, node.typeAnnotation);
			return node;
		}
		checkImportReflection(node) {
			super.checkImportReflection(node);
			if (node.module && node.importKind !== "value") this.raise(FlowErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
		}
		parseImportSpecifierLocal(node, specifier, type) {
			specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
			node.specifiers.push(this.finishImportSpecifier(specifier, type));
		}
		isPotentialImportPhase(isExport) {
			if (super.isPotentialImportPhase(isExport)) return true;
			if (this.isContextual(130)) {
				if (!isExport) return true;
				const ch = this.lookaheadCharCode();
				return ch === 123 || ch === 42;
			}
			return !isExport && this.isContextual(87);
		}
		applyImportPhase(node, isExport, phase, loc) {
			super.applyImportPhase(node, isExport, phase, loc);
			if (isExport) {
				if (!phase && this.match(65)) return;
				node.exportKind = phase === "type" ? phase : "value";
			} else {
				if (phase === "type" && this.match(55)) this.unexpected();
				node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
			}
		}
		parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
			const firstIdent = specifier.imported;
			let specifierTypeKind = null;
			if (firstIdent.type === "Identifier") {
				if (firstIdent.name === "type") specifierTypeKind = "type";
				else if (firstIdent.name === "typeof") specifierTypeKind = "typeof";
			}
			let isBinding = false;
			if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
				const as_ident = this.parseIdentifier(true);
				if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
					specifier.imported = as_ident;
					specifier.importKind = specifierTypeKind;
					specifier.local = this.cloneIdentifier(as_ident);
				} else {
					specifier.imported = firstIdent;
					specifier.importKind = null;
					specifier.local = this.parseIdentifier();
				}
			} else {
				if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
					specifier.imported = this.parseIdentifier(true);
					specifier.importKind = specifierTypeKind;
				} else {
					if (importedIsString) throw this.raise(Errors.ImportBindingIsString, specifier, { importName: firstIdent.value });
					specifier.imported = firstIdent;
					specifier.importKind = null;
				}
				if (this.eatContextual(93)) specifier.local = this.parseIdentifier();
				else {
					isBinding = true;
					specifier.local = this.cloneIdentifier(specifier.imported);
				}
			}
			const specifierIsTypeImport = hasTypeImportKind(specifier);
			if (isInTypeOnlyImport && specifierIsTypeImport) this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, specifier);
			if (isInTypeOnlyImport || specifierIsTypeImport) this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
			if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
			return this.finishImportSpecifier(specifier, "ImportSpecifier");
		}
		parseBindingAtom() {
			switch (this.state.type) {
				case 78: return this.parseIdentifier(true);
				default: return super.parseBindingAtom();
			}
		}
		parseFunctionParams(node, isConstructor) {
			const kind = node.kind;
			if (kind !== "get" && kind !== "set" && this.match(47)) node.typeParameters = this.flowParseTypeParameterDeclaration();
			super.parseFunctionParams(node, isConstructor);
		}
		parseVarId(decl, kind) {
			super.parseVarId(decl, kind);
			if (this.match(14)) {
				decl.id.typeAnnotation = this.flowParseTypeAnnotation();
				this.resetEndLocation(decl.id);
			}
		}
		parseAsyncArrowFromCallExpression(node, call) {
			if (this.match(14)) {
				const oldNoAnonFunctionType = this.state.noAnonFunctionType;
				this.state.noAnonFunctionType = true;
				node.returnType = this.flowParseTypeAnnotation();
				this.state.noAnonFunctionType = oldNoAnonFunctionType;
			}
			return super.parseAsyncArrowFromCallExpression(node, call);
		}
		shouldParseAsyncArrow() {
			return this.match(14) || super.shouldParseAsyncArrow();
		}
		parseMaybeAssign(refExpressionErrors, afterLeftParse) {
			var _jsx;
			let state = null;
			let jsx;
			if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) {
				state = this.state.clone();
				jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
				if (!jsx.error) return jsx.node;
				const { context } = this.state;
				const currentContext = context[context.length - 1];
				if (currentContext === types.j_oTag || currentContext === types.j_expr) context.pop();
			}
			if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {
				var _jsx2, _jsx3;
				state = state || this.state.clone();
				let typeParameters;
				const arrow = this.tryParse((abort) => {
					var _arrowExpression$extr;
					typeParameters = this.flowParseTypeParameterDeclaration();
					const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
						const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
						this.resetStartLocationFromNode(result, typeParameters);
						return result;
					});
					if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();
					const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);
					if (expr.type !== "ArrowFunctionExpression") abort();
					expr.typeParameters = typeParameters;
					this.resetStartLocationFromNode(expr, typeParameters);
					return arrowExpression;
				}, state);
				let arrowExpression = null;
				if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
					if (!arrow.error && !arrow.aborted) {
						if (arrow.node.async) this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, typeParameters);
						return arrow.node;
					}
					arrowExpression = arrow.node;
				}
				if ((_jsx2 = jsx) != null && _jsx2.node) {
					this.state = jsx.failState;
					return jsx.node;
				}
				if (arrowExpression) {
					this.state = arrow.failState;
					return arrowExpression;
				}
				if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
				if (arrow.thrown) throw arrow.error;
				throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, typeParameters);
			}
			return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
		}
		parseArrow(node) {
			if (this.match(14)) {
				const result = this.tryParse(() => {
					const oldNoAnonFunctionType = this.state.noAnonFunctionType;
					this.state.noAnonFunctionType = true;
					const typeNode = this.startNode();
					[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
					this.state.noAnonFunctionType = oldNoAnonFunctionType;
					if (this.canInsertSemicolon()) this.unexpected();
					if (!this.match(19)) this.unexpected();
					return typeNode;
				});
				if (result.thrown) return null;
				if (result.error) this.state = result.failState;
				node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
			}
			return super.parseArrow(node);
		}
		shouldParseArrow(params) {
			return this.match(14) || super.shouldParseArrow(params);
		}
		setArrowFunctionParameters(node, params) {
			if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) node.params = params;
			else super.setArrowFunctionParameters(node, params);
		}
		checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
			if (isArrowFunction && this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) return;
			for (let i = 0; i < node.params.length; i++) if (this.isThisParam(node.params[i]) && i > 0) this.raise(FlowErrors.ThisParamMustBeFirst, node.params[i]);
			super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
		}
		parseParenAndDistinguishExpression(canBeArrow) {
			return super.parseParenAndDistinguishExpression(canBeArrow && !this.state.noArrowAt.includes(this.sourceToOffsetPos(this.state.start)));
		}
		parseSubscripts(base, startLoc, noCalls) {
			if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.includes(startLoc.index)) {
				this.next();
				const node = this.startNodeAt(startLoc);
				node.callee = base;
				node.arguments = super.parseCallExpressionArguments();
				base = this.finishNode(node, "CallExpression");
			} else if (base.type === "Identifier" && base.name === "async" && this.match(47)) {
				const state = this.state.clone();
				const arrow = this.tryParse((abort) => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);
				if (!arrow.error && !arrow.aborted) return arrow.node;
				const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);
				if (result.node && !result.error) return result.node;
				if (arrow.node) {
					this.state = arrow.failState;
					return arrow.node;
				}
				if (result.node) {
					this.state = result.failState;
					return result.node;
				}
				throw arrow.error || result.error;
			}
			return super.parseSubscripts(base, startLoc, noCalls);
		}
		parseSubscript(base, startLoc, noCalls, subscriptState) {
			if (this.match(18) && this.isLookaheadToken_lt()) {
				subscriptState.optionalChainMember = true;
				if (noCalls) {
					subscriptState.stop = true;
					return base;
				}
				this.next();
				const node = this.startNodeAt(startLoc);
				node.callee = base;
				node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
				this.expect(10);
				node.arguments = this.parseCallExpressionArguments();
				node.optional = true;
				return this.finishCallExpression(node, true);
			} else if (!noCalls && this.shouldParseTypes() && (this.match(47) || this.match(51))) {
				const node = this.startNodeAt(startLoc);
				node.callee = base;
				const result = this.tryParse(() => {
					node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
					this.expect(10);
					node.arguments = super.parseCallExpressionArguments();
					if (subscriptState.optionalChainMember) node.optional = false;
					return this.finishCallExpression(node, subscriptState.optionalChainMember);
				});
				if (result.node) {
					if (result.error) this.state = result.failState;
					return result.node;
				}
			}
			return super.parseSubscript(base, startLoc, noCalls, subscriptState);
		}
		parseNewCallee(node) {
			super.parseNewCallee(node);
			let targs = null;
			if (this.shouldParseTypes() && this.match(47)) targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
			node.typeArguments = targs;
		}
		parseAsyncArrowWithTypeParameters(startLoc) {
			const node = this.startNodeAt(startLoc);
			this.parseFunctionParams(node, false);
			if (!this.parseArrow(node)) return;
			return super.parseArrowExpression(node, void 0, true);
		}
		readToken_mult_modulo(code) {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (code === 42 && next === 47 && this.state.hasFlowComment) {
				this.state.hasFlowComment = false;
				this.state.pos += 2;
				this.nextToken();
				return;
			}
			super.readToken_mult_modulo(code);
		}
		readToken_pipe_amp(code) {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (code === 124 && next === 125) {
				this.finishOp(9, 2);
				return;
			}
			super.readToken_pipe_amp(code);
		}
		parseTopLevel(file, program) {
			const fileNode = super.parseTopLevel(file, program);
			if (this.state.hasFlowComment) this.raise(FlowErrors.UnterminatedFlowComment, this.state.curPosition());
			return fileNode;
		}
		skipBlockComment() {
			if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
				if (this.state.hasFlowComment) throw this.raise(FlowErrors.NestedFlowComment, this.state.startLoc);
				this.hasFlowCommentCompletion();
				const commentSkip = this.skipFlowComment();
				if (commentSkip) {
					this.state.pos += commentSkip;
					this.state.hasFlowComment = true;
				}
				return;
			}
			return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
		}
		skipFlowComment() {
			const { pos } = this.state;
			let shiftToFirstNonWhiteSpace = 2;
			while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) shiftToFirstNonWhiteSpace++;
			const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
			const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
			if (ch2 === 58 && ch3 === 58) return shiftToFirstNonWhiteSpace + 2;
			if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") return shiftToFirstNonWhiteSpace + 12;
			if (ch2 === 58 && ch3 !== 58) return shiftToFirstNonWhiteSpace;
			return false;
		}
		hasFlowCommentCompletion() {
			if (this.input.indexOf("*/", this.state.pos) === -1) throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
		}
		flowEnumErrorBooleanMemberNotInitialized(loc, { enumName, memberName }) {
			this.raise(FlowErrors.EnumBooleanMemberNotInitialized, loc, {
				memberName,
				enumName
			});
		}
		flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
			return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, loc, enumContext);
		}
		flowEnumErrorNumberMemberNotInitialized(loc, details) {
			this.raise(FlowErrors.EnumNumberMemberNotInitialized, loc, details);
		}
		flowEnumErrorStringMemberInconsistentlyInitialized(node, details) {
			this.raise(FlowErrors.EnumStringMemberInconsistentlyInitialized, node, details);
		}
		flowEnumMemberInit() {
			const startLoc = this.state.startLoc;
			const endOfInit = () => this.match(12) || this.match(8);
			switch (this.state.type) {
				case 135: {
					const literal = this.parseNumericLiteral(this.state.value);
					if (endOfInit()) return {
						type: "number",
						loc: literal.loc.start,
						value: literal
					};
					return {
						type: "invalid",
						loc: startLoc
					};
				}
				case 134: {
					const literal = this.parseStringLiteral(this.state.value);
					if (endOfInit()) return {
						type: "string",
						loc: literal.loc.start,
						value: literal
					};
					return {
						type: "invalid",
						loc: startLoc
					};
				}
				case 85:
				case 86: {
					const literal = this.parseBooleanLiteral(this.match(85));
					if (endOfInit()) return {
						type: "boolean",
						loc: literal.loc.start,
						value: literal
					};
					return {
						type: "invalid",
						loc: startLoc
					};
				}
				default: return {
					type: "invalid",
					loc: startLoc
				};
			}
		}
		flowEnumMemberRaw() {
			const loc = this.state.startLoc;
			return {
				id: this.parseIdentifier(true),
				init: this.eat(29) ? this.flowEnumMemberInit() : {
					type: "none",
					loc
				}
			};
		}
		flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
			const { explicitType } = context;
			if (explicitType === null) return;
			if (explicitType !== expectedType) this.flowEnumErrorInvalidMemberInitializer(loc, context);
		}
		flowEnumMembers({ enumName, explicitType }) {
			const seenNames = /* @__PURE__ */ new Set();
			const members = {
				booleanMembers: [],
				numberMembers: [],
				stringMembers: [],
				defaultedMembers: []
			};
			let hasUnknownMembers = false;
			while (!this.match(8)) {
				if (this.eat(21)) {
					hasUnknownMembers = true;
					break;
				}
				const memberNode = this.startNode();
				const { id, init } = this.flowEnumMemberRaw();
				const memberName = id.name;
				if (memberName === "") continue;
				if (/^[a-z]/.test(memberName)) this.raise(FlowErrors.EnumInvalidMemberName, id, {
					memberName,
					suggestion: memberName[0].toUpperCase() + memberName.slice(1),
					enumName
				});
				if (seenNames.has(memberName)) this.raise(FlowErrors.EnumDuplicateMemberName, id, {
					memberName,
					enumName
				});
				seenNames.add(memberName);
				const context = {
					enumName,
					explicitType,
					memberName
				};
				memberNode.id = id;
				switch (init.type) {
					case "boolean":
						this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
						memberNode.init = init.value;
						members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
						break;
					case "number":
						this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
						memberNode.init = init.value;
						members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
						break;
					case "string":
						this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
						memberNode.init = init.value;
						members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
						break;
					case "invalid": throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
					case "none": switch (explicitType) {
						case "boolean":
							this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
							break;
						case "number":
							this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
							break;
						default: members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
					}
				}
				if (!this.match(8)) this.expect(12);
			}
			return {
				members,
				hasUnknownMembers
			};
		}
		flowEnumStringMembers(initializedMembers, defaultedMembers, { enumName }) {
			if (initializedMembers.length === 0) return defaultedMembers;
			else if (defaultedMembers.length === 0) return initializedMembers;
			else if (defaultedMembers.length > initializedMembers.length) {
				for (const member of initializedMembers) this.flowEnumErrorStringMemberInconsistentlyInitialized(member, { enumName });
				return defaultedMembers;
			} else {
				for (const member of defaultedMembers) this.flowEnumErrorStringMemberInconsistentlyInitialized(member, { enumName });
				return initializedMembers;
			}
		}
		flowEnumParseExplicitType({ enumName }) {
			if (!this.eatContextual(102)) return null;
			if (!tokenIsIdentifier(this.state.type)) throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, this.state.startLoc, { enumName });
			const { value } = this.state;
			this.next();
			if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") this.raise(FlowErrors.EnumInvalidExplicitType, this.state.startLoc, {
				enumName,
				invalidEnumType: value
			});
			return value;
		}
		flowEnumBody(node, id) {
			const enumName = id.name;
			const nameLoc = id.loc.start;
			const explicitType = this.flowEnumParseExplicitType({ enumName });
			this.expect(5);
			const { members, hasUnknownMembers } = this.flowEnumMembers({
				enumName,
				explicitType
			});
			node.hasUnknownMembers = hasUnknownMembers;
			switch (explicitType) {
				case "boolean":
					node.explicitType = true;
					node.members = members.booleanMembers;
					this.expect(8);
					return this.finishNode(node, "EnumBooleanBody");
				case "number":
					node.explicitType = true;
					node.members = members.numberMembers;
					this.expect(8);
					return this.finishNode(node, "EnumNumberBody");
				case "string":
					node.explicitType = true;
					node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { enumName });
					this.expect(8);
					return this.finishNode(node, "EnumStringBody");
				case "symbol":
					node.members = members.defaultedMembers;
					this.expect(8);
					return this.finishNode(node, "EnumSymbolBody");
				default: {
					const empty = () => {
						node.members = [];
						this.expect(8);
						return this.finishNode(node, "EnumStringBody");
					};
					node.explicitType = false;
					const boolsLen = members.booleanMembers.length;
					const numsLen = members.numberMembers.length;
					const strsLen = members.stringMembers.length;
					const defaultedLen = members.defaultedMembers.length;
					if (!boolsLen && !numsLen && !strsLen && !defaultedLen) return empty();
					else if (!boolsLen && !numsLen) {
						node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, { enumName });
						this.expect(8);
						return this.finishNode(node, "EnumStringBody");
					} else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
						for (const member of members.defaultedMembers) this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
							enumName,
							memberName: member.id.name
						});
						node.members = members.booleanMembers;
						this.expect(8);
						return this.finishNode(node, "EnumBooleanBody");
					} else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
						for (const member of members.defaultedMembers) this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
							enumName,
							memberName: member.id.name
						});
						node.members = members.numberMembers;
						this.expect(8);
						return this.finishNode(node, "EnumNumberBody");
					} else {
						this.raise(FlowErrors.EnumInconsistentMemberValues, nameLoc, { enumName });
						return empty();
					}
				}
			}
		}
		flowParseEnumDeclaration(node) {
			const id = this.parseIdentifier();
			node.id = id;
			node.body = this.flowEnumBody(this.startNode(), id);
			return this.finishNode(node, "EnumDeclaration");
		}
		jsxParseOpeningElementAfterName(node) {
			if (this.shouldParseTypes()) {
				if (this.match(47) || this.match(51)) node.typeArguments = this.flowParseTypeParameterInstantiationInExpression();
			}
			return super.jsxParseOpeningElementAfterName(node);
		}
		isLookaheadToken_lt() {
			const next = this.nextTokenStart();
			if (this.input.charCodeAt(next) === 60) {
				const afterNext = this.input.charCodeAt(next + 1);
				return afterNext !== 60 && afterNext !== 61;
			}
			return false;
		}
		reScan_lt_gt() {
			const { type } = this.state;
			if (type === 47) {
				this.state.pos -= 1;
				this.readToken_lt();
			} else if (type === 48) {
				this.state.pos -= 1;
				this.readToken_gt();
			}
		}
		reScan_lt() {
			const { type } = this.state;
			if (type === 51) {
				this.state.pos -= 2;
				this.finishOp(47, 1);
				return 47;
			}
			return type;
		}
		maybeUnwrapTypeCastExpression(node) {
			return node.type === "TypeCastExpression" ? node.expression : node;
		}
	};
	const entities = {
		__proto__: null,
		quot: "\"",
		amp: "&",
		apos: "'",
		lt: "<",
		gt: ">",
		nbsp: "\xA0",
		iexcl: "¡",
		cent: "¢",
		pound: "£",
		curren: "¤",
		yen: "¥",
		brvbar: "¦",
		sect: "§",
		uml: "¨",
		copy: "©",
		ordf: "ª",
		laquo: "«",
		not: "¬",
		shy: "­",
		reg: "®",
		macr: "¯",
		deg: "°",
		plusmn: "±",
		sup2: "²",
		sup3: "³",
		acute: "´",
		micro: "µ",
		para: "¶",
		middot: "·",
		cedil: "¸",
		sup1: "¹",
		ordm: "º",
		raquo: "»",
		frac14: "¼",
		frac12: "½",
		frac34: "¾",
		iquest: "¿",
		Agrave: "À",
		Aacute: "Á",
		Acirc: "Â",
		Atilde: "Ã",
		Auml: "Ä",
		Aring: "Å",
		AElig: "Æ",
		Ccedil: "Ç",
		Egrave: "È",
		Eacute: "É",
		Ecirc: "Ê",
		Euml: "Ë",
		Igrave: "Ì",
		Iacute: "Í",
		Icirc: "Î",
		Iuml: "Ï",
		ETH: "Ð",
		Ntilde: "Ñ",
		Ograve: "Ò",
		Oacute: "Ó",
		Ocirc: "Ô",
		Otilde: "Õ",
		Ouml: "Ö",
		times: "×",
		Oslash: "Ø",
		Ugrave: "Ù",
		Uacute: "Ú",
		Ucirc: "Û",
		Uuml: "Ü",
		Yacute: "Ý",
		THORN: "Þ",
		szlig: "ß",
		agrave: "à",
		aacute: "á",
		acirc: "â",
		atilde: "ã",
		auml: "ä",
		aring: "å",
		aelig: "æ",
		ccedil: "ç",
		egrave: "è",
		eacute: "é",
		ecirc: "ê",
		euml: "ë",
		igrave: "ì",
		iacute: "í",
		icirc: "î",
		iuml: "ï",
		eth: "ð",
		ntilde: "ñ",
		ograve: "ò",
		oacute: "ó",
		ocirc: "ô",
		otilde: "õ",
		ouml: "ö",
		divide: "÷",
		oslash: "ø",
		ugrave: "ù",
		uacute: "ú",
		ucirc: "û",
		uuml: "ü",
		yacute: "ý",
		thorn: "þ",
		yuml: "ÿ",
		OElig: "Œ",
		oelig: "œ",
		Scaron: "Š",
		scaron: "š",
		Yuml: "Ÿ",
		fnof: "ƒ",
		circ: "ˆ",
		tilde: "˜",
		Alpha: "Α",
		Beta: "Β",
		Gamma: "Γ",
		Delta: "Δ",
		Epsilon: "Ε",
		Zeta: "Ζ",
		Eta: "Η",
		Theta: "Θ",
		Iota: "Ι",
		Kappa: "Κ",
		Lambda: "Λ",
		Mu: "Μ",
		Nu: "Ν",
		Xi: "Ξ",
		Omicron: "Ο",
		Pi: "Π",
		Rho: "Ρ",
		Sigma: "Σ",
		Tau: "Τ",
		Upsilon: "Υ",
		Phi: "Φ",
		Chi: "Χ",
		Psi: "Ψ",
		Omega: "Ω",
		alpha: "α",
		beta: "β",
		gamma: "γ",
		delta: "δ",
		epsilon: "ε",
		zeta: "ζ",
		eta: "η",
		theta: "θ",
		iota: "ι",
		kappa: "κ",
		lambda: "λ",
		mu: "μ",
		nu: "ν",
		xi: "ξ",
		omicron: "ο",
		pi: "π",
		rho: "ρ",
		sigmaf: "ς",
		sigma: "σ",
		tau: "τ",
		upsilon: "υ",
		phi: "φ",
		chi: "χ",
		psi: "ψ",
		omega: "ω",
		thetasym: "ϑ",
		upsih: "ϒ",
		piv: "ϖ",
		ensp: " ",
		emsp: " ",
		thinsp: " ",
		zwnj: "‌",
		zwj: "‍",
		lrm: "‎",
		rlm: "‏",
		ndash: "–",
		mdash: "—",
		lsquo: "‘",
		rsquo: "’",
		sbquo: "‚",
		ldquo: "“",
		rdquo: "”",
		bdquo: "„",
		dagger: "†",
		Dagger: "‡",
		bull: "•",
		hellip: "…",
		permil: "‰",
		prime: "′",
		Prime: "″",
		lsaquo: "‹",
		rsaquo: "›",
		oline: "‾",
		frasl: "⁄",
		euro: "€",
		image: "ℑ",
		weierp: "℘",
		real: "ℜ",
		trade: "™",
		alefsym: "ℵ",
		larr: "←",
		uarr: "↑",
		rarr: "→",
		darr: "↓",
		harr: "↔",
		crarr: "↵",
		lArr: "⇐",
		uArr: "⇑",
		rArr: "⇒",
		dArr: "⇓",
		hArr: "⇔",
		forall: "∀",
		part: "∂",
		exist: "∃",
		empty: "∅",
		nabla: "∇",
		isin: "∈",
		notin: "∉",
		ni: "∋",
		prod: "∏",
		sum: "∑",
		minus: "−",
		lowast: "∗",
		radic: "√",
		prop: "∝",
		infin: "∞",
		ang: "∠",
		and: "∧",
		or: "∨",
		cap: "∩",
		cup: "∪",
		int: "∫",
		there4: "∴",
		sim: "∼",
		cong: "≅",
		asymp: "≈",
		ne: "≠",
		equiv: "≡",
		le: "≤",
		ge: "≥",
		sub: "⊂",
		sup: "⊃",
		nsub: "⊄",
		sube: "⊆",
		supe: "⊇",
		oplus: "⊕",
		otimes: "⊗",
		perp: "⊥",
		sdot: "⋅",
		lceil: "⌈",
		rceil: "⌉",
		lfloor: "⌊",
		rfloor: "⌋",
		lang: "〈",
		rang: "〉",
		loz: "◊",
		spades: "♠",
		clubs: "♣",
		hearts: "♥",
		diams: "♦"
	};
	const lineBreakG = new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
	function isNewLine(code) {
		switch (code) {
			case 10:
			case 13:
			case 8232:
			case 8233: return true;
			default: return false;
		}
	}
	function hasNewLine(input, start, end) {
		for (let i = start; i < end; i++) if (isNewLine(input.charCodeAt(i))) return true;
		return false;
	}
	const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
	const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/g;
	function isWhitespace(code) {
		switch (code) {
			case 9:
			case 11:
			case 12:
			case 32:
			case 160:
			case 5760:
			case 8192:
			case 8193:
			case 8194:
			case 8195:
			case 8196:
			case 8197:
			case 8198:
			case 8199:
			case 8200:
			case 8201:
			case 8202:
			case 8239:
			case 8287:
			case 12288:
			case 65279: return true;
			default: return false;
		}
	}
	const JsxErrors = ParseErrorEnum`jsx`({
		AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
		MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
		MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
		UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
		UnexpectedToken: ({ unexpected, HTMLEntity }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
		UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
		UnterminatedJsxContent: "Unterminated JSX contents.",
		UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
	});
	function isFragment(object) {
		return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
	}
	function getQualifiedJSXName(object) {
		if (object.type === "JSXIdentifier") return object.name;
		if (object.type === "JSXNamespacedName") return object.namespace.name + ":" + object.name.name;
		if (object.type === "JSXMemberExpression") return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
		throw new Error("Node had unexpected type: " + object.type);
	}
	var jsx = (superClass) => class JSXParserMixin extends superClass {
		jsxReadToken() {
			let out = "";
			let chunkStart = this.state.pos;
			for (;;) {
				if (this.state.pos >= this.length) throw this.raise(JsxErrors.UnterminatedJsxContent, this.state.startLoc);
				const ch = this.input.charCodeAt(this.state.pos);
				switch (ch) {
					case 60:
					case 123:
						if (this.state.pos === this.state.start) {
							if (ch === 60 && this.state.canStartJSXElement) {
								++this.state.pos;
								this.finishToken(143);
							} else super.getTokenFromCode(ch);
							return;
						}
						out += this.input.slice(chunkStart, this.state.pos);
						this.finishToken(142, out);
						return;
					case 38:
						out += this.input.slice(chunkStart, this.state.pos);
						out += this.jsxReadEntity();
						chunkStart = this.state.pos;
						break;
					default: if (isNewLine(ch)) {
						out += this.input.slice(chunkStart, this.state.pos);
						out += this.jsxReadNewLine(true);
						chunkStart = this.state.pos;
					} else ++this.state.pos;
				}
			}
		}
		jsxReadNewLine(normalizeCRLF) {
			const ch = this.input.charCodeAt(this.state.pos);
			let out;
			++this.state.pos;
			if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
				++this.state.pos;
				out = normalizeCRLF ? "\n" : "\r\n";
			} else out = String.fromCharCode(ch);
			++this.state.curLine;
			this.state.lineStart = this.state.pos;
			return out;
		}
		jsxReadString(quote) {
			let out = "";
			let chunkStart = ++this.state.pos;
			for (;;) {
				if (this.state.pos >= this.length) throw this.raise(Errors.UnterminatedString, this.state.startLoc);
				const ch = this.input.charCodeAt(this.state.pos);
				if (ch === quote) break;
				if (ch === 38) {
					out += this.input.slice(chunkStart, this.state.pos);
					out += this.jsxReadEntity();
					chunkStart = this.state.pos;
				} else if (isNewLine(ch)) {
					out += this.input.slice(chunkStart, this.state.pos);
					out += this.jsxReadNewLine(false);
					chunkStart = this.state.pos;
				} else ++this.state.pos;
			}
			out += this.input.slice(chunkStart, this.state.pos++);
			this.finishToken(134, out);
		}
		jsxReadEntity() {
			const startPos = ++this.state.pos;
			if (this.codePointAtPos(this.state.pos) === 35) {
				++this.state.pos;
				let radix = 10;
				if (this.codePointAtPos(this.state.pos) === 120) {
					radix = 16;
					++this.state.pos;
				}
				const codePoint = this.readInt(radix, void 0, false, "bail");
				if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
					++this.state.pos;
					return String.fromCodePoint(codePoint);
				}
			} else {
				let count = 0;
				let semi = false;
				while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) === 59)) ++this.state.pos;
				if (semi) {
					const desc = this.input.slice(startPos, this.state.pos);
					const entity = entities[desc];
					++this.state.pos;
					if (entity) return entity;
				}
			}
			this.state.pos = startPos;
			return "&";
		}
		jsxReadWord() {
			let ch;
			const start = this.state.pos;
			do
				ch = this.input.charCodeAt(++this.state.pos);
			while (isIdentifierChar(ch) || ch === 45);
			this.finishToken(141, this.input.slice(start, this.state.pos));
		}
		jsxParseIdentifier() {
			const node = this.startNode();
			if (this.match(141)) node.name = this.state.value;
			else if (tokenIsKeyword(this.state.type)) node.name = tokenLabelName(this.state.type);
			else this.unexpected();
			this.next();
			return this.finishNode(node, "JSXIdentifier");
		}
		jsxParseNamespacedName() {
			const startLoc = this.state.startLoc;
			const name = this.jsxParseIdentifier();
			if (!this.eat(14)) return name;
			const node = this.startNodeAt(startLoc);
			node.namespace = name;
			node.name = this.jsxParseIdentifier();
			return this.finishNode(node, "JSXNamespacedName");
		}
		jsxParseElementName() {
			const startLoc = this.state.startLoc;
			let node = this.jsxParseNamespacedName();
			if (node.type === "JSXNamespacedName") return node;
			while (this.eat(16)) {
				const newNode = this.startNodeAt(startLoc);
				newNode.object = node;
				newNode.property = this.jsxParseIdentifier();
				node = this.finishNode(newNode, "JSXMemberExpression");
			}
			return node;
		}
		jsxParseAttributeValue() {
			let node;
			switch (this.state.type) {
				case 5:
					node = this.startNode();
					this.setContext(types.brace);
					this.next();
					node = this.jsxParseExpressionContainer(node, types.j_oTag);
					if (node.expression.type === "JSXEmptyExpression") this.raise(JsxErrors.AttributeIsEmpty, node);
					return node;
				case 143:
				case 134: return this.parseExprAtom();
				default: throw this.raise(JsxErrors.UnsupportedJsxValue, this.state.startLoc);
			}
		}
		jsxParseEmptyExpression() {
			const node = this.startNodeAt(this.state.lastTokEndLoc);
			return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
		}
		jsxParseSpreadChild(node) {
			this.next();
			node.expression = this.parseExpression();
			this.setContext(types.j_expr);
			this.state.canStartJSXElement = true;
			this.expect(8);
			return this.finishNode(node, "JSXSpreadChild");
		}
		jsxParseExpressionContainer(node, previousContext) {
			if (this.match(8)) node.expression = this.jsxParseEmptyExpression();
			else node.expression = this.parseExpression();
			this.setContext(previousContext);
			this.state.canStartJSXElement = true;
			this.expect(8);
			return this.finishNode(node, "JSXExpressionContainer");
		}
		jsxParseAttribute() {
			const node = this.startNode();
			if (this.match(5)) {
				this.setContext(types.brace);
				this.next();
				this.expect(21);
				node.argument = this.parseMaybeAssignAllowIn();
				this.setContext(types.j_oTag);
				this.state.canStartJSXElement = true;
				this.expect(8);
				return this.finishNode(node, "JSXSpreadAttribute");
			}
			node.name = this.jsxParseNamespacedName();
			node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
			return this.finishNode(node, "JSXAttribute");
		}
		jsxParseOpeningElementAt(startLoc) {
			const node = this.startNodeAt(startLoc);
			if (this.eat(144)) return this.finishNode(node, "JSXOpeningFragment");
			node.name = this.jsxParseElementName();
			return this.jsxParseOpeningElementAfterName(node);
		}
		jsxParseOpeningElementAfterName(node) {
			const attributes = [];
			while (!this.match(56) && !this.match(144)) attributes.push(this.jsxParseAttribute());
			node.attributes = attributes;
			node.selfClosing = this.eat(56);
			this.expect(144);
			return this.finishNode(node, "JSXOpeningElement");
		}
		jsxParseClosingElementAt(startLoc) {
			const node = this.startNodeAt(startLoc);
			if (this.eat(144)) return this.finishNode(node, "JSXClosingFragment");
			node.name = this.jsxParseElementName();
			this.expect(144);
			return this.finishNode(node, "JSXClosingElement");
		}
		jsxParseElementAt(startLoc) {
			const node = this.startNodeAt(startLoc);
			const children = [];
			const openingElement = this.jsxParseOpeningElementAt(startLoc);
			let closingElement = null;
			if (!openingElement.selfClosing) {
				contents: for (;;) switch (this.state.type) {
					case 143:
						startLoc = this.state.startLoc;
						this.next();
						if (this.eat(56)) {
							closingElement = this.jsxParseClosingElementAt(startLoc);
							break contents;
						}
						children.push(this.jsxParseElementAt(startLoc));
						break;
					case 142:
						children.push(this.parseLiteral(this.state.value, "JSXText"));
						break;
					case 5: {
						const node = this.startNode();
						this.setContext(types.brace);
						this.next();
						if (this.match(21)) children.push(this.jsxParseSpreadChild(node));
						else children.push(this.jsxParseExpressionContainer(node, types.j_expr));
						break;
					}
					default: this.unexpected();
				}
				if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) this.raise(JsxErrors.MissingClosingTagFragment, closingElement);
				else if (!isFragment(openingElement) && isFragment(closingElement)) this.raise(JsxErrors.MissingClosingTagElement, closingElement, { openingTagName: getQualifiedJSXName(openingElement.name) });
				else if (!isFragment(openingElement) && !isFragment(closingElement)) {
					if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) this.raise(JsxErrors.MissingClosingTagElement, closingElement, { openingTagName: getQualifiedJSXName(openingElement.name) });
				}
			}
			if (isFragment(openingElement)) {
				node.openingFragment = openingElement;
				node.closingFragment = closingElement;
			} else {
				node.openingElement = openingElement;
				node.closingElement = closingElement;
			}
			node.children = children;
			if (this.match(47)) throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, this.state.startLoc);
			return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
		}
		jsxParseElement() {
			const startLoc = this.state.startLoc;
			this.next();
			return this.jsxParseElementAt(startLoc);
		}
		setContext(newContext) {
			const { context } = this.state;
			context[context.length - 1] = newContext;
		}
		parseExprAtom(refExpressionErrors) {
			if (this.match(143)) return this.jsxParseElement();
			else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
				this.replaceToken(143);
				return this.jsxParseElement();
			} else return super.parseExprAtom(refExpressionErrors);
		}
		skipSpace() {
			if (!this.curContext().preserveSpace) super.skipSpace();
		}
		getTokenFromCode(code) {
			const context = this.curContext();
			if (context === types.j_expr) {
				this.jsxReadToken();
				return;
			}
			if (context === types.j_oTag || context === types.j_cTag) {
				if (isIdentifierStart(code)) {
					this.jsxReadWord();
					return;
				}
				if (code === 62) {
					++this.state.pos;
					this.finishToken(144);
					return;
				}
				if ((code === 34 || code === 39) && context === types.j_oTag) {
					this.jsxReadString(code);
					return;
				}
			}
			if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
				++this.state.pos;
				this.finishToken(143);
				return;
			}
			super.getTokenFromCode(code);
		}
		updateContext(prevType) {
			const { context, type } = this.state;
			if (type === 56 && prevType === 143) {
				context.splice(-2, 2, types.j_cTag);
				this.state.canStartJSXElement = false;
			} else if (type === 143) context.push(types.j_oTag);
			else if (type === 144) {
				const out = context[context.length - 1];
				if (out === types.j_oTag && prevType === 56 || out === types.j_cTag) {
					context.pop();
					this.state.canStartJSXElement = context[context.length - 1] === types.j_expr;
				} else {
					this.setContext(types.j_expr);
					this.state.canStartJSXElement = true;
				}
			} else this.state.canStartJSXElement = tokenComesBeforeExpression(type);
		}
	};
	var TypeScriptScope = class extends Scope {
		constructor(...args) {
			super(...args);
			this.tsNames = /* @__PURE__ */ new Map();
		}
	};
	var TypeScriptScopeHandler = class extends ScopeHandler {
		constructor(...args) {
			super(...args);
			this.importsStack = [];
		}
		createScope(flags) {
			this.importsStack.push(/* @__PURE__ */ new Set());
			return new TypeScriptScope(flags);
		}
		enter(flags) {
			if (flags === 1024) this.importsStack.push(/* @__PURE__ */ new Set());
			super.enter(flags);
		}
		exit() {
			const flags = super.exit();
			if (flags === 1024) this.importsStack.pop();
			return flags;
		}
		hasImport(name, allowShadow) {
			const len = this.importsStack.length;
			if (this.importsStack[len - 1].has(name)) return true;
			if (!allowShadow && len > 1) {
				for (let i = 0; i < len - 1; i++) if (this.importsStack[i].has(name)) return true;
			}
			return false;
		}
		declareName(name, bindingType, loc) {
			if (bindingType & 4096) {
				if (this.hasImport(name, true)) this.parser.raise(Errors.VarRedeclaration, loc, { identifierName: name });
				this.importsStack[this.importsStack.length - 1].add(name);
				return;
			}
			const scope = this.currentScope();
			let type = scope.tsNames.get(name) || 0;
			if (bindingType & 1024) {
				this.maybeExportDefined(scope, name);
				scope.tsNames.set(name, type | 16);
				return;
			}
			super.declareName(name, bindingType, loc);
			if (bindingType & 2) {
				if (!(bindingType & 1)) {
					this.checkRedeclarationInScope(scope, name, bindingType, loc);
					this.maybeExportDefined(scope, name);
				}
				type = type | 1;
			}
			if (bindingType & 256) type = type | 2;
			if (bindingType & 512) type = type | 4;
			if (bindingType & 128) type = type | 8;
			if (type) scope.tsNames.set(name, type);
		}
		isRedeclaredInScope(scope, name, bindingType) {
			const type = scope.tsNames.get(name);
			if ((type & 2) > 0) {
				if (bindingType & 256) return !!(bindingType & 512) !== (type & 4) > 0;
				return true;
			}
			if (bindingType & 128 && (type & 8) > 0) {
				if (scope.names.get(name) & 2) return !!(bindingType & 1);
				else return false;
			}
			if (bindingType & 2 && (type & 1) > 0) return true;
			return super.isRedeclaredInScope(scope, name, bindingType);
		}
		checkLocalExport(id) {
			const { name } = id;
			if (this.hasImport(name)) return;
			const len = this.scopeStack.length;
			for (let i = len - 1; i >= 0; i--) {
				const type = this.scopeStack[i].tsNames.get(name);
				if ((type & 1) > 0 || (type & 16) > 0) return;
			}
			super.checkLocalExport(id);
		}
	};
	var ProductionParameterHandler = class {
		constructor() {
			this.stacks = [];
		}
		enter(flags) {
			this.stacks.push(flags);
		}
		exit() {
			this.stacks.pop();
		}
		currentFlags() {
			return this.stacks[this.stacks.length - 1];
		}
		get hasAwait() {
			return (this.currentFlags() & 2) > 0;
		}
		get hasYield() {
			return (this.currentFlags() & 1) > 0;
		}
		get hasReturn() {
			return (this.currentFlags() & 4) > 0;
		}
		get hasIn() {
			return (this.currentFlags() & 8) > 0;
		}
	};
	function functionFlags(isAsync, isGenerator) {
		return (isAsync ? 2 : 0) | (isGenerator ? 1 : 0);
	}
	var BaseParser = class {
		constructor() {
			this.sawUnambiguousESM = false;
			this.ambiguousScriptDifferentAst = false;
		}
		sourceToOffsetPos(sourcePos) {
			return sourcePos + this.startIndex;
		}
		offsetToSourcePos(offsetPos) {
			return offsetPos - this.startIndex;
		}
		hasPlugin(pluginConfig) {
			if (typeof pluginConfig === "string") return this.plugins.has(pluginConfig);
			else {
				const [pluginName, pluginOptions] = pluginConfig;
				if (!this.hasPlugin(pluginName)) return false;
				const actualOptions = this.plugins.get(pluginName);
				for (const key of Object.keys(pluginOptions)) if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) return false;
				return true;
			}
		}
		getPluginOption(plugin, name) {
			var _this$plugins$get;
			return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name];
		}
	};
	function setTrailingComments(node, comments) {
		if (node.trailingComments === void 0) node.trailingComments = comments;
		else node.trailingComments.unshift(...comments);
	}
	function setLeadingComments(node, comments) {
		if (node.leadingComments === void 0) node.leadingComments = comments;
		else node.leadingComments.unshift(...comments);
	}
	function setInnerComments(node, comments) {
		if (node.innerComments === void 0) node.innerComments = comments;
		else node.innerComments.unshift(...comments);
	}
	function adjustInnerComments(node, elements, commentWS) {
		let lastElement = null;
		let i = elements.length;
		while (lastElement === null && i > 0) lastElement = elements[--i];
		if (lastElement === null || lastElement.start > commentWS.start) setInnerComments(node, commentWS.comments);
		else setTrailingComments(lastElement, commentWS.comments);
	}
	var CommentsParser = class extends BaseParser {
		addComment(comment) {
			if (this.filename) comment.loc.filename = this.filename;
			const { commentsLen } = this.state;
			if (this.comments.length !== commentsLen) this.comments.length = commentsLen;
			this.comments.push(comment);
			this.state.commentsLen++;
		}
		processComment(node) {
			const { commentStack } = this.state;
			const commentStackLength = commentStack.length;
			if (commentStackLength === 0) return;
			let i = commentStackLength - 1;
			const lastCommentWS = commentStack[i];
			if (lastCommentWS.start === node.end) {
				lastCommentWS.leadingNode = node;
				i--;
			}
			const { start: nodeStart } = node;
			for (; i >= 0; i--) {
				const commentWS = commentStack[i];
				const commentEnd = commentWS.end;
				if (commentEnd > nodeStart) {
					commentWS.containingNode = node;
					this.finalizeComment(commentWS);
					commentStack.splice(i, 1);
				} else {
					if (commentEnd === nodeStart) commentWS.trailingNode = node;
					break;
				}
			}
		}
		finalizeComment(commentWS) {
			var _node$options;
			const { comments } = commentWS;
			if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {
				if (commentWS.leadingNode !== null) setTrailingComments(commentWS.leadingNode, comments);
				if (commentWS.trailingNode !== null) setLeadingComments(commentWS.trailingNode, comments);
			} else {
				const node = commentWS.containingNode;
				const commentStart = commentWS.start;
				if (this.input.charCodeAt(this.offsetToSourcePos(commentStart) - 1) === 44) switch (node.type) {
					case "ObjectExpression":
					case "ObjectPattern":
						adjustInnerComments(node, node.properties, commentWS);
						break;
					case "CallExpression":
					case "NewExpression":
					case "OptionalCallExpression":
						adjustInnerComments(node, node.arguments, commentWS);
						break;
					case "ImportExpression":
						adjustInnerComments(node, [node.source, (_node$options = node.options) != null ? _node$options : null], commentWS);
						break;
					case "FunctionDeclaration":
					case "FunctionExpression":
					case "ArrowFunctionExpression":
					case "ObjectMethod":
					case "ClassMethod":
					case "ClassPrivateMethod":
					case "TSTypeParameterDeclaration":
						adjustInnerComments(node, node.params, commentWS);
						break;
					case "ArrayExpression":
					case "ArrayPattern":
						adjustInnerComments(node, node.elements, commentWS);
						break;
					case "ExportNamedDeclaration":
					case "ImportDeclaration":
						adjustInnerComments(node, node.specifiers, commentWS);
						break;
					case "TSEnumDeclaration":
						adjustInnerComments(node, node.members, commentWS);
						break;
					case "TSEnumBody":
						adjustInnerComments(node, node.members, commentWS);
						break;
					case "TSInterfaceBody":
						adjustInnerComments(node, node.body, commentWS);
						break;
					default:
						if (node.type === "RecordExpression") {
							adjustInnerComments(node, node.properties, commentWS);
							break;
						}
						if (node.type === "TupleExpression") {
							adjustInnerComments(node, node.elements, commentWS);
							break;
						}
						setInnerComments(node, comments);
				}
				else setInnerComments(node, comments);
			}
		}
		finalizeRemainingComments() {
			const { commentStack } = this.state;
			for (let i = commentStack.length - 1; i >= 0; i--) this.finalizeComment(commentStack[i]);
			this.state.commentStack = [];
		}
		resetPreviousNodeTrailingComments(node) {
			const { commentStack } = this.state;
			const { length } = commentStack;
			if (length === 0) return;
			const commentWS = commentStack[length - 1];
			if (commentWS.leadingNode === node) commentWS.leadingNode = null;
		}
		takeSurroundingComments(node, start, end) {
			const { commentStack } = this.state;
			const commentStackLength = commentStack.length;
			if (commentStackLength === 0) return;
			let i = commentStackLength - 1;
			for (; i >= 0; i--) {
				const commentWS = commentStack[i];
				const commentEnd = commentWS.end;
				if (commentWS.start === end) commentWS.leadingNode = node;
				else if (commentEnd === start) commentWS.trailingNode = node;
				else if (commentEnd < start) break;
			}
		}
	};
	var State = class State {
		constructor() {
			this.flags = 1024;
			this.startIndex = void 0;
			this.curLine = void 0;
			this.lineStart = void 0;
			this.startLoc = void 0;
			this.endLoc = void 0;
			this.errors = [];
			this.potentialArrowAt = -1;
			this.noArrowAt = [];
			this.noArrowParamsConversionAt = [];
			this.topicContext = {
				maxNumOfResolvableTopics: 0,
				maxTopicIndex: null
			};
			this.labels = [];
			this.commentsLen = 0;
			this.commentStack = [];
			this.pos = 0;
			this.type = 140;
			this.value = null;
			this.start = 0;
			this.end = 0;
			this.lastTokEndLoc = null;
			this.lastTokStartLoc = null;
			this.context = [types.brace];
			this.firstInvalidTemplateEscapePos = null;
			this.strictErrors = /* @__PURE__ */ new Map();
			this.tokensLength = 0;
		}
		get strict() {
			return (this.flags & 1) > 0;
		}
		set strict(v) {
			if (v) this.flags |= 1;
			else this.flags &= -2;
		}
		init({ strictMode, sourceType, startIndex, startLine, startColumn }) {
			this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module";
			this.startIndex = startIndex;
			this.curLine = startLine;
			this.lineStart = -startColumn;
			this.startLoc = this.endLoc = new Position(startLine, startColumn, startIndex);
		}
		get maybeInArrowParameters() {
			return (this.flags & 2) > 0;
		}
		set maybeInArrowParameters(v) {
			if (v) this.flags |= 2;
			else this.flags &= -3;
		}
		get inType() {
			return (this.flags & 4) > 0;
		}
		set inType(v) {
			if (v) this.flags |= 4;
			else this.flags &= -5;
		}
		get noAnonFunctionType() {
			return (this.flags & 8) > 0;
		}
		set noAnonFunctionType(v) {
			if (v) this.flags |= 8;
			else this.flags &= -9;
		}
		get hasFlowComment() {
			return (this.flags & 16) > 0;
		}
		set hasFlowComment(v) {
			if (v) this.flags |= 16;
			else this.flags &= -17;
		}
		get isAmbientContext() {
			return (this.flags & 32) > 0;
		}
		set isAmbientContext(v) {
			if (v) this.flags |= 32;
			else this.flags &= -33;
		}
		get inAbstractClass() {
			return (this.flags & 64) > 0;
		}
		set inAbstractClass(v) {
			if (v) this.flags |= 64;
			else this.flags &= -65;
		}
		get inDisallowConditionalTypesContext() {
			return (this.flags & 128) > 0;
		}
		set inDisallowConditionalTypesContext(v) {
			if (v) this.flags |= 128;
			else this.flags &= -129;
		}
		get soloAwait() {
			return (this.flags & 256) > 0;
		}
		set soloAwait(v) {
			if (v) this.flags |= 256;
			else this.flags &= -257;
		}
		get inFSharpPipelineDirectBody() {
			return (this.flags & 512) > 0;
		}
		set inFSharpPipelineDirectBody(v) {
			if (v) this.flags |= 512;
			else this.flags &= -513;
		}
		get canStartJSXElement() {
			return (this.flags & 1024) > 0;
		}
		set canStartJSXElement(v) {
			if (v) this.flags |= 1024;
			else this.flags &= -1025;
		}
		get containsEsc() {
			return (this.flags & 2048) > 0;
		}
		set containsEsc(v) {
			if (v) this.flags |= 2048;
			else this.flags &= -2049;
		}
		get hasTopLevelAwait() {
			return (this.flags & 4096) > 0;
		}
		set hasTopLevelAwait(v) {
			if (v) this.flags |= 4096;
			else this.flags &= -4097;
		}
		curPosition() {
			return new Position(this.curLine, this.pos - this.lineStart, this.pos + this.startIndex);
		}
		clone() {
			const state = new State();
			state.flags = this.flags;
			state.startIndex = this.startIndex;
			state.curLine = this.curLine;
			state.lineStart = this.lineStart;
			state.startLoc = this.startLoc;
			state.endLoc = this.endLoc;
			state.errors = this.errors.slice();
			state.potentialArrowAt = this.potentialArrowAt;
			state.noArrowAt = this.noArrowAt.slice();
			state.noArrowParamsConversionAt = this.noArrowParamsConversionAt.slice();
			state.topicContext = this.topicContext;
			state.labels = this.labels.slice();
			state.commentsLen = this.commentsLen;
			state.commentStack = this.commentStack.slice();
			state.pos = this.pos;
			state.type = this.type;
			state.value = this.value;
			state.start = this.start;
			state.end = this.end;
			state.lastTokEndLoc = this.lastTokEndLoc;
			state.lastTokStartLoc = this.lastTokStartLoc;
			state.context = this.context.slice();
			state.firstInvalidTemplateEscapePos = this.firstInvalidTemplateEscapePos;
			state.strictErrors = this.strictErrors;
			state.tokensLength = this.tokensLength;
			return state;
		}
	};
	var _isDigit = function isDigit(code) {
		return code >= 48 && code <= 57;
	};
	const forbiddenNumericSeparatorSiblings = {
		decBinOct: /* @__PURE__ */ new Set([
			46,
			66,
			69,
			79,
			95,
			98,
			101,
			111
		]),
		hex: /* @__PURE__ */ new Set([
			46,
			88,
			95,
			120
		])
	};
	const isAllowedNumericSeparatorSibling = {
		bin: (ch) => ch === 48 || ch === 49,
		oct: (ch) => ch >= 48 && ch <= 55,
		dec: (ch) => ch >= 48 && ch <= 57,
		hex: (ch) => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
	};
	function readStringContents(type, input, pos, lineStart, curLine, errors) {
		const initialPos = pos;
		const initialLineStart = lineStart;
		const initialCurLine = curLine;
		let out = "";
		let firstInvalidLoc = null;
		let chunkStart = pos;
		const { length } = input;
		for (;;) {
			if (pos >= length) {
				errors.unterminated(initialPos, initialLineStart, initialCurLine);
				out += input.slice(chunkStart, pos);
				break;
			}
			const ch = input.charCodeAt(pos);
			if (isStringEnd(type, ch, input, pos)) {
				out += input.slice(chunkStart, pos);
				break;
			}
			if (ch === 92) {
				out += input.slice(chunkStart, pos);
				const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
				if (res.ch === null && !firstInvalidLoc) firstInvalidLoc = {
					pos,
					lineStart,
					curLine
				};
				else out += res.ch;
				({pos, lineStart, curLine} = res);
				chunkStart = pos;
			} else if (ch === 8232 || ch === 8233) {
				++pos;
				++curLine;
				lineStart = pos;
			} else if (ch === 10 || ch === 13) {
				if (type === "template") {
					out += input.slice(chunkStart, pos) + "\n";
					++pos;
					if (ch === 13 && input.charCodeAt(pos) === 10) ++pos;
					++curLine;
					chunkStart = lineStart = pos;
				} else errors.unterminated(initialPos, initialLineStart, initialCurLine);
			} else ++pos;
		}
		return {
			pos,
			str: out,
			firstInvalidLoc,
			lineStart,
			curLine,
			containsInvalid: !!firstInvalidLoc
		};
	}
	function isStringEnd(type, ch, input, pos) {
		if (type === "template") return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
		return ch === (type === "double" ? 34 : 39);
	}
	function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
		const throwOnInvalid = !inTemplate;
		pos++;
		const res = (ch) => ({
			pos,
			ch,
			lineStart,
			curLine
		});
		const ch = input.charCodeAt(pos++);
		switch (ch) {
			case 110: return res("\n");
			case 114: return res("\r");
			case 120: {
				let code;
				({code, pos} = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
				return res(code === null ? null : String.fromCharCode(code));
			}
			case 117: {
				let code;
				({code, pos} = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
				return res(code === null ? null : String.fromCodePoint(code));
			}
			case 116: return res("	");
			case 98: return res("\b");
			case 118: return res("\v");
			case 102: return res("\f");
			case 13: if (input.charCodeAt(pos) === 10) ++pos;
			case 10:
				lineStart = pos;
				++curLine;
			case 8232:
			case 8233: return res("");
			case 56:
			case 57: if (inTemplate) return res(null);
			else errors.strictNumericEscape(pos - 1, lineStart, curLine);
			default:
				if (ch >= 48 && ch <= 55) {
					const startPos = pos - 1;
					let octalStr = /^[0-7]+/.exec(input.slice(startPos, pos + 2))[0];
					let octal = parseInt(octalStr, 8);
					if (octal > 255) {
						octalStr = octalStr.slice(0, -1);
						octal = parseInt(octalStr, 8);
					}
					pos += octalStr.length - 1;
					const next = input.charCodeAt(pos);
					if (octalStr !== "0" || next === 56 || next === 57) {
						if (inTemplate) return res(null);
						else errors.strictNumericEscape(startPos, lineStart, curLine);
					}
					return res(String.fromCharCode(octal));
				}
				return res(String.fromCharCode(ch));
		}
	}
	function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
		const initialPos = pos;
		let n;
		({n, pos} = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
		if (n === null) {
			if (throwOnInvalid) errors.invalidEscapeSequence(initialPos, lineStart, curLine);
			else pos = initialPos - 1;
		}
		return {
			code: n,
			pos
		};
	}
	function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
		const start = pos;
		const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
		const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
		let invalid = false;
		let total = 0;
		for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
			const code = input.charCodeAt(pos);
			let val;
			if (code === 95 && allowNumSeparator !== "bail") {
				const prev = input.charCodeAt(pos - 1);
				const next = input.charCodeAt(pos + 1);
				if (!allowNumSeparator) {
					if (bailOnError) return {
						n: null,
						pos
					};
					errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
				} else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
					if (bailOnError) return {
						n: null,
						pos
					};
					errors.unexpectedNumericSeparator(pos, lineStart, curLine);
				}
				++pos;
				continue;
			}
			if (code >= 97) val = code - 97 + 10;
			else if (code >= 65) val = code - 65 + 10;
			else if (_isDigit(code)) val = code - 48;
			else val = Infinity;
			if (val >= radix) {
				if (val <= 9 && bailOnError) return {
					n: null,
					pos
				};
				else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) val = 0;
				else if (forceLen) {
					val = 0;
					invalid = true;
				} else break;
			}
			++pos;
			total = total * radix + val;
		}
		if (pos === start || len != null && pos - start !== len || invalid) return {
			n: null,
			pos
		};
		return {
			n: total,
			pos
		};
	}
	function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
		const ch = input.charCodeAt(pos);
		let code;
		if (ch === 123) {
			++pos;
			({code, pos} = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
			++pos;
			if (code !== null && code > 1114111) {
				if (throwOnInvalid) errors.invalidCodePoint(pos, lineStart, curLine);
				else return {
					code: null,
					pos
				};
			}
		} else ({code, pos} = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
		return {
			code,
			pos
		};
	}
	function buildPosition(pos, lineStart, curLine) {
		return new Position(curLine, pos - lineStart, pos);
	}
	const VALID_REGEX_FLAGS = /* @__PURE__ */ new Set([
		103,
		109,
		115,
		105,
		121,
		117,
		100,
		118
	]);
	var Token = class {
		constructor(state) {
			const startIndex = state.startIndex || 0;
			this.type = state.type;
			this.value = state.value;
			this.start = startIndex + state.start;
			this.end = startIndex + state.end;
			this.loc = new SourceLocation(state.startLoc, state.endLoc);
		}
	};
	var Tokenizer = class extends CommentsParser {
		constructor(options, input) {
			super();
			this.isLookahead = void 0;
			this.tokens = [];
			this.errorHandlers_readInt = {
				invalidDigit: (pos, lineStart, curLine, radix) => {
					if (!(this.optionFlags & 2048)) return false;
					this.raise(Errors.InvalidDigit, buildPosition(pos, lineStart, curLine), { radix });
					return true;
				},
				numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
				unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)
			};
			this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {
				invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
				invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)
			});
			this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
				strictNumericEscape: (pos, lineStart, curLine) => {
					this.recordStrictModeErrors(Errors.StrictNumericEscape, buildPosition(pos, lineStart, curLine));
				},
				unterminated: (pos, lineStart, curLine) => {
					throw this.raise(Errors.UnterminatedString, buildPosition(pos - 1, lineStart, curLine));
				}
			});
			this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
				strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
				unterminated: (pos, lineStart, curLine) => {
					throw this.raise(Errors.UnterminatedTemplate, buildPosition(pos, lineStart, curLine));
				}
			});
			this.state = new State();
			this.state.init(options);
			this.input = input;
			this.length = input.length;
			this.comments = [];
			this.isLookahead = false;
		}
		pushToken(token) {
			this.tokens.length = this.state.tokensLength;
			this.tokens.push(token);
			++this.state.tokensLength;
		}
		next() {
			this.checkKeywordEscapes();
			if (this.optionFlags & 256) this.pushToken(new Token(this.state));
			this.state.lastTokEndLoc = this.state.endLoc;
			this.state.lastTokStartLoc = this.state.startLoc;
			this.nextToken();
		}
		eat(type) {
			if (this.match(type)) {
				this.next();
				return true;
			} else return false;
		}
		match(type) {
			return this.state.type === type;
		}
		createLookaheadState(state) {
			return {
				pos: state.pos,
				value: null,
				type: state.type,
				start: state.start,
				end: state.end,
				context: [this.curContext()],
				inType: state.inType,
				startLoc: state.startLoc,
				lastTokEndLoc: state.lastTokEndLoc,
				curLine: state.curLine,
				lineStart: state.lineStart,
				curPosition: state.curPosition
			};
		}
		lookahead() {
			const old = this.state;
			this.state = this.createLookaheadState(old);
			this.isLookahead = true;
			this.nextToken();
			this.isLookahead = false;
			const curr = this.state;
			this.state = old;
			return curr;
		}
		nextTokenStart() {
			return this.nextTokenStartSince(this.state.pos);
		}
		nextTokenStartSince(pos) {
			skipWhiteSpace.lastIndex = pos;
			return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;
		}
		lookaheadCharCode() {
			return this.lookaheadCharCodeSince(this.state.pos);
		}
		lookaheadCharCodeSince(pos) {
			return this.input.charCodeAt(this.nextTokenStartSince(pos));
		}
		nextTokenInLineStart() {
			return this.nextTokenInLineStartSince(this.state.pos);
		}
		nextTokenInLineStartSince(pos) {
			skipWhiteSpaceInLine.lastIndex = pos;
			return skipWhiteSpaceInLine.test(this.input) ? skipWhiteSpaceInLine.lastIndex : pos;
		}
		lookaheadInLineCharCode() {
			return this.input.charCodeAt(this.nextTokenInLineStart());
		}
		codePointAtPos(pos) {
			let cp = this.input.charCodeAt(pos);
			if ((cp & 64512) === 55296 && ++pos < this.input.length) {
				const trail = this.input.charCodeAt(pos);
				if ((trail & 64512) === 56320) cp = 65536 + ((cp & 1023) << 10) + (trail & 1023);
			}
			return cp;
		}
		setStrict(strict) {
			this.state.strict = strict;
			if (strict) {
				this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, at));
				this.state.strictErrors.clear();
			}
		}
		curContext() {
			return this.state.context[this.state.context.length - 1];
		}
		nextToken() {
			this.skipSpace();
			this.state.start = this.state.pos;
			if (!this.isLookahead) this.state.startLoc = this.state.curPosition();
			if (this.state.pos >= this.length) {
				this.finishToken(140);
				return;
			}
			this.getTokenFromCode(this.codePointAtPos(this.state.pos));
		}
		skipBlockComment(commentEnd) {
			let startLoc;
			if (!this.isLookahead) startLoc = this.state.curPosition();
			const start = this.state.pos;
			const end = this.input.indexOf(commentEnd, start + 2);
			if (end === -1) throw this.raise(Errors.UnterminatedComment, this.state.curPosition());
			this.state.pos = end + commentEnd.length;
			lineBreakG.lastIndex = start + 2;
			while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {
				++this.state.curLine;
				this.state.lineStart = lineBreakG.lastIndex;
			}
			if (this.isLookahead) return;
			const comment = {
				type: "CommentBlock",
				value: this.input.slice(start + 2, end),
				start: this.sourceToOffsetPos(start),
				end: this.sourceToOffsetPos(end + commentEnd.length),
				loc: new SourceLocation(startLoc, this.state.curPosition())
			};
			if (this.optionFlags & 256) this.pushToken(comment);
			return comment;
		}
		skipLineComment(startSkip) {
			const start = this.state.pos;
			let startLoc;
			if (!this.isLookahead) startLoc = this.state.curPosition();
			let ch = this.input.charCodeAt(this.state.pos += startSkip);
			if (this.state.pos < this.length) while (!isNewLine(ch) && ++this.state.pos < this.length) ch = this.input.charCodeAt(this.state.pos);
			if (this.isLookahead) return;
			const end = this.state.pos;
			const comment = {
				type: "CommentLine",
				value: this.input.slice(start + startSkip, end),
				start: this.sourceToOffsetPos(start),
				end: this.sourceToOffsetPos(end),
				loc: new SourceLocation(startLoc, this.state.curPosition())
			};
			if (this.optionFlags & 256) this.pushToken(comment);
			return comment;
		}
		skipSpace() {
			const spaceStart = this.state.pos;
			const comments = this.optionFlags & 4096 ? [] : null;
			loop: while (this.state.pos < this.length) {
				const ch = this.input.charCodeAt(this.state.pos);
				switch (ch) {
					case 32:
					case 160:
					case 9:
						++this.state.pos;
						break;
					case 13: if (this.input.charCodeAt(this.state.pos + 1) === 10) ++this.state.pos;
					case 10:
					case 8232:
					case 8233:
						++this.state.pos;
						++this.state.curLine;
						this.state.lineStart = this.state.pos;
						break;
					case 47:
						switch (this.input.charCodeAt(this.state.pos + 1)) {
							case 42: {
								const comment = this.skipBlockComment("*/");
								if (comment !== void 0) {
									this.addComment(comment);
									comments == null || comments.push(comment);
								}
								break;
							}
							case 47: {
								const comment = this.skipLineComment(2);
								if (comment !== void 0) {
									this.addComment(comment);
									comments == null || comments.push(comment);
								}
								break;
							}
							default: break loop;
						}
						break;
					default: if (isWhitespace(ch)) ++this.state.pos;
					else if (ch === 45 && !this.inModule && this.optionFlags & 8192) {
						const pos = this.state.pos;
						if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
							const comment = this.skipLineComment(3);
							if (comment !== void 0) {
								this.addComment(comment);
								comments == null || comments.push(comment);
							}
						} else break loop;
					} else if (ch === 60 && !this.inModule && this.optionFlags & 8192) {
						const pos = this.state.pos;
						if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
							const comment = this.skipLineComment(4);
							if (comment !== void 0) {
								this.addComment(comment);
								comments == null || comments.push(comment);
							}
						} else break loop;
					} else break loop;
				}
			}
			if ((comments == null ? void 0 : comments.length) > 0) {
				const end = this.state.pos;
				const commentWhitespace = {
					start: this.sourceToOffsetPos(spaceStart),
					end: this.sourceToOffsetPos(end),
					comments,
					leadingNode: null,
					trailingNode: null,
					containingNode: null
				};
				this.state.commentStack.push(commentWhitespace);
			}
		}
		finishToken(type, val) {
			this.state.end = this.state.pos;
			this.state.endLoc = this.state.curPosition();
			const prevType = this.state.type;
			this.state.type = type;
			this.state.value = val;
			if (!this.isLookahead) this.updateContext(prevType);
		}
		replaceToken(type) {
			this.state.type = type;
			this.updateContext();
		}
		readToken_numberSign() {
			if (this.state.pos === 0 && this.readToken_interpreter()) return;
			const nextPos = this.state.pos + 1;
			const next = this.codePointAtPos(nextPos);
			if (next >= 48 && next <= 57) throw this.raise(Errors.UnexpectedDigitAfterHash, this.state.curPosition());
			if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
				this.expectPlugin("recordAndTuple");
				if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, this.state.curPosition());
				this.state.pos += 2;
				if (next === 123) this.finishToken(7);
				else this.finishToken(1);
			} else if (isIdentifierStart(next)) {
				++this.state.pos;
				this.finishToken(139, this.readWord1(next));
			} else if (next === 92) {
				++this.state.pos;
				this.finishToken(139, this.readWord1());
			} else this.finishOp(27, 1);
		}
		readToken_dot() {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (next >= 48 && next <= 57) {
				this.readNumber(true);
				return;
			}
			if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
				this.state.pos += 3;
				this.finishToken(21);
			} else {
				++this.state.pos;
				this.finishToken(16);
			}
		}
		readToken_slash() {
			if (this.input.charCodeAt(this.state.pos + 1) === 61) this.finishOp(31, 2);
			else this.finishOp(56, 1);
		}
		readToken_interpreter() {
			if (this.state.pos !== 0 || this.length < 2) return false;
			let ch = this.input.charCodeAt(this.state.pos + 1);
			if (ch !== 33) return false;
			const start = this.state.pos;
			this.state.pos += 1;
			while (!isNewLine(ch) && ++this.state.pos < this.length) ch = this.input.charCodeAt(this.state.pos);
			const value = this.input.slice(start + 2, this.state.pos);
			this.finishToken(28, value);
			return true;
		}
		readToken_mult_modulo(code) {
			let type = code === 42 ? 55 : 54;
			let width = 1;
			let next = this.input.charCodeAt(this.state.pos + 1);
			if (code === 42 && next === 42) {
				width++;
				next = this.input.charCodeAt(this.state.pos + 2);
				type = 57;
			}
			if (next === 61 && !this.state.inType) {
				width++;
				type = code === 37 ? 33 : 30;
			}
			this.finishOp(type, width);
		}
		readToken_pipe_amp(code) {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (next === code) {
				if (this.input.charCodeAt(this.state.pos + 2) === 61) this.finishOp(30, 3);
				else this.finishOp(code === 124 ? 41 : 42, 2);
				return;
			}
			if (code === 124) {
				if (next === 62) {
					this.finishOp(39, 2);
					return;
				}
				if (this.hasPlugin("recordAndTuple") && next === 125) {
					if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, this.state.curPosition());
					this.state.pos += 2;
					this.finishToken(9);
					return;
				}
				if (this.hasPlugin("recordAndTuple") && next === 93) {
					if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, this.state.curPosition());
					this.state.pos += 2;
					this.finishToken(4);
					return;
				}
			}
			if (next === 61) {
				this.finishOp(30, 2);
				return;
			}
			this.finishOp(code === 124 ? 43 : 45, 1);
		}
		readToken_caret() {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (next === 61 && !this.state.inType) this.finishOp(32, 2);
			else if (next === 94 && this.hasPlugin(["pipelineOperator", {
				proposal: "hack",
				topicToken: "^^"
			}])) {
				this.finishOp(37, 2);
				if (this.input.codePointAt(this.state.pos) === 94) this.unexpected();
			} else this.finishOp(44, 1);
		}
		readToken_atSign() {
			if (this.input.charCodeAt(this.state.pos + 1) === 64 && this.hasPlugin(["pipelineOperator", {
				proposal: "hack",
				topicToken: "@@"
			}])) this.finishOp(38, 2);
			else this.finishOp(26, 1);
		}
		readToken_plus_min(code) {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (next === code) {
				this.finishOp(34, 2);
				return;
			}
			if (next === 61) this.finishOp(30, 2);
			else this.finishOp(53, 1);
		}
		readToken_lt() {
			const { pos } = this.state;
			const next = this.input.charCodeAt(pos + 1);
			if (next === 60) {
				if (this.input.charCodeAt(pos + 2) === 61) {
					this.finishOp(30, 3);
					return;
				}
				this.finishOp(51, 2);
				return;
			}
			if (next === 61) {
				this.finishOp(49, 2);
				return;
			}
			this.finishOp(47, 1);
		}
		readToken_gt() {
			const { pos } = this.state;
			const next = this.input.charCodeAt(pos + 1);
			if (next === 62) {
				const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;
				if (this.input.charCodeAt(pos + size) === 61) {
					this.finishOp(30, size + 1);
					return;
				}
				this.finishOp(52, size);
				return;
			}
			if (next === 61) {
				this.finishOp(49, 2);
				return;
			}
			this.finishOp(48, 1);
		}
		readToken_eq_excl(code) {
			const next = this.input.charCodeAt(this.state.pos + 1);
			if (next === 61) {
				this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
				return;
			}
			if (code === 61 && next === 62) {
				this.state.pos += 2;
				this.finishToken(19);
				return;
			}
			this.finishOp(code === 61 ? 29 : 35, 1);
		}
		readToken_question() {
			const next = this.input.charCodeAt(this.state.pos + 1);
			const next2 = this.input.charCodeAt(this.state.pos + 2);
			if (next === 63) {
				if (next2 === 61) this.finishOp(30, 3);
				else this.finishOp(40, 2);
			} else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
				this.state.pos += 2;
				this.finishToken(18);
			} else {
				++this.state.pos;
				this.finishToken(17);
			}
		}
		getTokenFromCode(code) {
			switch (code) {
				case 46:
					this.readToken_dot();
					return;
				case 40:
					++this.state.pos;
					this.finishToken(10);
					return;
				case 41:
					++this.state.pos;
					this.finishToken(11);
					return;
				case 59:
					++this.state.pos;
					this.finishToken(13);
					return;
				case 44:
					++this.state.pos;
					this.finishToken(12);
					return;
				case 91:
					if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
						if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, this.state.curPosition());
						this.state.pos += 2;
						this.finishToken(2);
					} else {
						++this.state.pos;
						this.finishToken(0);
					}
					return;
				case 93:
					++this.state.pos;
					this.finishToken(3);
					return;
				case 123:
					if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
						if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, this.state.curPosition());
						this.state.pos += 2;
						this.finishToken(6);
					} else {
						++this.state.pos;
						this.finishToken(5);
					}
					return;
				case 125:
					++this.state.pos;
					this.finishToken(8);
					return;
				case 58:
					if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) this.finishOp(15, 2);
					else {
						++this.state.pos;
						this.finishToken(14);
					}
					return;
				case 63:
					this.readToken_question();
					return;
				case 96:
					this.readTemplateToken();
					return;
				case 48: {
					const next = this.input.charCodeAt(this.state.pos + 1);
					if (next === 120 || next === 88) {
						this.readRadixNumber(16);
						return;
					}
					if (next === 111 || next === 79) {
						this.readRadixNumber(8);
						return;
					}
					if (next === 98 || next === 66) {
						this.readRadixNumber(2);
						return;
					}
				}
				case 49:
				case 50:
				case 51:
				case 52:
				case 53:
				case 54:
				case 55:
				case 56:
				case 57:
					this.readNumber(false);
					return;
				case 34:
				case 39:
					this.readString(code);
					return;
				case 47:
					this.readToken_slash();
					return;
				case 37:
				case 42:
					this.readToken_mult_modulo(code);
					return;
				case 124:
				case 38:
					this.readToken_pipe_amp(code);
					return;
				case 94:
					this.readToken_caret();
					return;
				case 43:
				case 45:
					this.readToken_plus_min(code);
					return;
				case 60:
					this.readToken_lt();
					return;
				case 62:
					this.readToken_gt();
					return;
				case 61:
				case 33:
					this.readToken_eq_excl(code);
					return;
				case 126:
					this.finishOp(36, 1);
					return;
				case 64:
					this.readToken_atSign();
					return;
				case 35:
					this.readToken_numberSign();
					return;
				case 92:
					this.readWord();
					return;
				default: if (isIdentifierStart(code)) {
					this.readWord(code);
					return;
				}
			}
			throw this.raise(Errors.InvalidOrUnexpectedToken, this.state.curPosition(), { unexpected: String.fromCodePoint(code) });
		}
		finishOp(type, size) {
			const str = this.input.slice(this.state.pos, this.state.pos + size);
			this.state.pos += size;
			this.finishToken(type, str);
		}
		readRegexp() {
			const startLoc = this.state.startLoc;
			const start = this.state.start + 1;
			let escaped, inClass;
			let { pos } = this.state;
			for (;; ++pos) {
				if (pos >= this.length) throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
				const ch = this.input.charCodeAt(pos);
				if (isNewLine(ch)) throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
				if (escaped) escaped = false;
				else {
					if (ch === 91) inClass = true;
					else if (ch === 93 && inClass) inClass = false;
					else if (ch === 47 && !inClass) break;
					escaped = ch === 92;
				}
			}
			const content = this.input.slice(start, pos);
			++pos;
			let mods = "";
			const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start);
			while (pos < this.length) {
				const cp = this.codePointAtPos(pos);
				const char = String.fromCharCode(cp);
				if (VALID_REGEX_FLAGS.has(cp)) {
					if (cp === 118) {
						if (mods.includes("u")) this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());
					} else if (cp === 117) {
						if (mods.includes("v")) this.raise(Errors.IncompatibleRegExpUVFlags, nextPos());
					}
					if (mods.includes(char)) this.raise(Errors.DuplicateRegExpFlags, nextPos());
				} else if (isIdentifierChar(cp) || cp === 92) this.raise(Errors.MalformedRegExpFlags, nextPos());
				else break;
				++pos;
				mods += char;
			}
			this.state.pos = pos;
			this.finishToken(138, {
				pattern: content,
				flags: mods
			});
		}
		readInt(radix, len, forceLen = false, allowNumSeparator = true) {
			const { n, pos } = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
			this.state.pos = pos;
			return n;
		}
		readRadixNumber(radix) {
			const start = this.state.pos;
			const startLoc = this.state.curPosition();
			let isBigInt = false;
			this.state.pos += 2;
			const val = this.readInt(radix);
			if (val == null) this.raise(Errors.InvalidDigit, createPositionWithColumnOffset(startLoc, 2), { radix });
			const next = this.input.charCodeAt(this.state.pos);
			if (next === 110) {
				++this.state.pos;
				isBigInt = true;
			} else if (next === 109) throw this.raise(Errors.InvalidDecimal, startLoc);
			if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
			if (isBigInt) {
				const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
				this.finishToken(136, str);
				return;
			}
			this.finishToken(135, val);
		}
		readNumber(startsWithDot) {
			const start = this.state.pos;
			const startLoc = this.state.curPosition();
			let isFloat = false;
			let isBigInt = false;
			let hasExponent = false;
			let isOctal = false;
			if (!startsWithDot && this.readInt(10) === null) this.raise(Errors.InvalidNumber, this.state.curPosition());
			const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
			if (hasLeadingZero) {
				const integer = this.input.slice(start, this.state.pos);
				this.recordStrictModeErrors(Errors.StrictOctalLiteral, startLoc);
				if (!this.state.strict) {
					const underscorePos = integer.indexOf("_");
					if (underscorePos > 0) this.raise(Errors.ZeroDigitNumericSeparator, createPositionWithColumnOffset(startLoc, underscorePos));
				}
				isOctal = hasLeadingZero && !/[89]/.test(integer);
			}
			let next = this.input.charCodeAt(this.state.pos);
			if (next === 46 && !isOctal) {
				++this.state.pos;
				this.readInt(10);
				isFloat = true;
				next = this.input.charCodeAt(this.state.pos);
			}
			if ((next === 69 || next === 101) && !isOctal) {
				next = this.input.charCodeAt(++this.state.pos);
				if (next === 43 || next === 45) ++this.state.pos;
				if (this.readInt(10) === null) this.raise(Errors.InvalidOrMissingExponent, startLoc);
				isFloat = true;
				hasExponent = true;
				next = this.input.charCodeAt(this.state.pos);
			}
			if (next === 110) {
				if (isFloat || hasLeadingZero) this.raise(Errors.InvalidBigIntLiteral, startLoc);
				++this.state.pos;
				isBigInt = true;
			}
			if (next === 109) {
				this.expectPlugin("decimal", this.state.curPosition());
				if (hasExponent || hasLeadingZero) this.raise(Errors.InvalidDecimal, startLoc);
				++this.state.pos;
				var isDecimal = true;
			}
			if (isIdentifierStart(this.codePointAtPos(this.state.pos))) throw this.raise(Errors.NumberIdentifier, this.state.curPosition());
			const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
			if (isBigInt) {
				this.finishToken(136, str);
				return;
			}
			if (isDecimal) {
				this.finishToken(137, str);
				return;
			}
			const val = isOctal ? parseInt(str, 8) : parseFloat(str);
			this.finishToken(135, val);
		}
		readCodePoint(throwOnInvalid) {
			const { code, pos } = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
			this.state.pos = pos;
			return code;
		}
		readString(quote) {
			const { str, pos, curLine, lineStart } = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
			this.state.pos = pos + 1;
			this.state.lineStart = lineStart;
			this.state.curLine = curLine;
			this.finishToken(134, str);
		}
		readTemplateContinuation() {
			if (!this.match(8)) this.unexpected(null, 8);
			this.state.pos--;
			this.readTemplateToken();
		}
		readTemplateToken() {
			const opening = this.input[this.state.pos];
			const { str, firstInvalidLoc, pos, curLine, lineStart } = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
			this.state.pos = pos + 1;
			this.state.lineStart = lineStart;
			this.state.curLine = curLine;
			if (firstInvalidLoc) this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, this.sourceToOffsetPos(firstInvalidLoc.pos));
			if (this.input.codePointAt(pos) === 96) this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
			else {
				this.state.pos++;
				this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
			}
		}
		recordStrictModeErrors(toParseError, at) {
			const index = at.index;
			if (this.state.strict && !this.state.strictErrors.has(index)) this.raise(toParseError, at);
			else this.state.strictErrors.set(index, [toParseError, at]);
		}
		readWord1(firstCode) {
			this.state.containsEsc = false;
			let word = "";
			const start = this.state.pos;
			let chunkStart = this.state.pos;
			if (firstCode !== void 0) this.state.pos += firstCode <= 65535 ? 1 : 2;
			while (this.state.pos < this.length) {
				const ch = this.codePointAtPos(this.state.pos);
				if (isIdentifierChar(ch)) this.state.pos += ch <= 65535 ? 1 : 2;
				else if (ch === 92) {
					this.state.containsEsc = true;
					word += this.input.slice(chunkStart, this.state.pos);
					const escStart = this.state.curPosition();
					const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
					if (this.input.charCodeAt(++this.state.pos) !== 117) {
						this.raise(Errors.MissingUnicodeEscape, this.state.curPosition());
						chunkStart = this.state.pos - 1;
						continue;
					}
					++this.state.pos;
					const esc = this.readCodePoint(true);
					if (esc !== null) {
						if (!identifierCheck(esc)) this.raise(Errors.EscapedCharNotAnIdentifier, escStart);
						word += String.fromCodePoint(esc);
					}
					chunkStart = this.state.pos;
				} else break;
			}
			return word + this.input.slice(chunkStart, this.state.pos);
		}
		readWord(firstCode) {
			const word = this.readWord1(firstCode);
			const type = keywords$1.get(word);
			if (type !== void 0) this.finishToken(type, tokenLabelName(type));
			else this.finishToken(132, word);
		}
		checkKeywordEscapes() {
			const { type } = this.state;
			if (tokenIsKeyword(type) && this.state.containsEsc) this.raise(Errors.InvalidEscapedReservedWord, this.state.startLoc, { reservedWord: tokenLabelName(type) });
		}
		raise(toParseError, at, details = {}) {
			const error = toParseError(at instanceof Position ? at : at.loc.start, details);
			if (!(this.optionFlags & 2048)) throw error;
			if (!this.isLookahead) this.state.errors.push(error);
			return error;
		}
		raiseOverwrite(toParseError, at, details = {}) {
			const loc = at instanceof Position ? at : at.loc.start;
			const pos = loc.index;
			const errors = this.state.errors;
			for (let i = errors.length - 1; i >= 0; i--) {
				const error = errors[i];
				if (error.loc.index === pos) return errors[i] = toParseError(loc, details);
				if (error.loc.index < pos) break;
			}
			return this.raise(toParseError, at, details);
		}
		updateContext(prevType) {}
		unexpected(loc, type) {
			throw this.raise(Errors.UnexpectedToken, loc != null ? loc : this.state.startLoc, { expected: type ? tokenLabelName(type) : null });
		}
		expectPlugin(pluginName, loc) {
			if (this.hasPlugin(pluginName)) return true;
			throw this.raise(Errors.MissingPlugin, loc != null ? loc : this.state.startLoc, { missingPlugin: [pluginName] });
		}
		expectOnePlugin(pluginNames) {
			if (!pluginNames.some((name) => this.hasPlugin(name))) throw this.raise(Errors.MissingOneOfPlugins, this.state.startLoc, { missingPlugin: pluginNames });
		}
		errorBuilder(error) {
			return (pos, lineStart, curLine) => {
				this.raise(error, buildPosition(pos, lineStart, curLine));
			};
		}
	};
	var ClassScope = class {
		constructor() {
			this.privateNames = /* @__PURE__ */ new Set();
			this.loneAccessors = /* @__PURE__ */ new Map();
			this.undefinedPrivateNames = /* @__PURE__ */ new Map();
		}
	};
	var ClassScopeHandler = class {
		constructor(parser) {
			this.parser = void 0;
			this.stack = [];
			this.undefinedPrivateNames = /* @__PURE__ */ new Map();
			this.parser = parser;
		}
		current() {
			return this.stack[this.stack.length - 1];
		}
		enter() {
			this.stack.push(new ClassScope());
		}
		exit() {
			const oldClassScope = this.stack.pop();
			const current = this.current();
			for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) if (current) {
				if (!current.undefinedPrivateNames.has(name)) current.undefinedPrivateNames.set(name, loc);
			} else this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, { identifierName: name });
		}
		declarePrivateName(name, elementType, loc) {
			const { privateNames, loneAccessors, undefinedPrivateNames } = this.current();
			let redefined = privateNames.has(name);
			if (elementType & 3) {
				const accessor = redefined && loneAccessors.get(name);
				if (accessor) {
					const oldStatic = accessor & 4;
					const newStatic = elementType & 4;
					redefined = (accessor & 3) === (elementType & 3) || oldStatic !== newStatic;
					if (!redefined) loneAccessors.delete(name);
				} else if (!redefined) loneAccessors.set(name, elementType);
			}
			if (redefined) this.parser.raise(Errors.PrivateNameRedeclaration, loc, { identifierName: name });
			privateNames.add(name);
			undefinedPrivateNames.delete(name);
		}
		usePrivateName(name, loc) {
			let classScope;
			for (classScope of this.stack) if (classScope.privateNames.has(name)) return;
			if (classScope) classScope.undefinedPrivateNames.set(name, loc);
			else this.parser.raise(Errors.InvalidPrivateFieldResolution, loc, { identifierName: name });
		}
	};
	var ExpressionScope = class {
		constructor(type = 0) {
			this.type = type;
		}
		canBeArrowParameterDeclaration() {
			return this.type === 2 || this.type === 1;
		}
		isCertainlyParameterDeclaration() {
			return this.type === 3;
		}
	};
	var ArrowHeadParsingScope = class extends ExpressionScope {
		constructor(type) {
			super(type);
			this.declarationErrors = /* @__PURE__ */ new Map();
		}
		recordDeclarationError(ParsingErrorClass, at) {
			const index = at.index;
			this.declarationErrors.set(index, [ParsingErrorClass, at]);
		}
		clearDeclarationError(index) {
			this.declarationErrors.delete(index);
		}
		iterateErrors(iterator) {
			this.declarationErrors.forEach(iterator);
		}
	};
	var ExpressionScopeHandler = class {
		constructor(parser) {
			this.parser = void 0;
			this.stack = [new ExpressionScope()];
			this.parser = parser;
		}
		enter(scope) {
			this.stack.push(scope);
		}
		exit() {
			this.stack.pop();
		}
		recordParameterInitializerError(toParseError, node) {
			const origin = node.loc.start;
			const { stack } = this;
			let i = stack.length - 1;
			let scope = stack[i];
			while (!scope.isCertainlyParameterDeclaration()) {
				if (scope.canBeArrowParameterDeclaration()) scope.recordDeclarationError(toParseError, origin);
				else return;
				scope = stack[--i];
			}
			this.parser.raise(toParseError, origin);
		}
		recordArrowParameterBindingError(error, node) {
			const { stack } = this;
			const scope = stack[stack.length - 1];
			const origin = node.loc.start;
			if (scope.isCertainlyParameterDeclaration()) this.parser.raise(error, origin);
			else if (scope.canBeArrowParameterDeclaration()) scope.recordDeclarationError(error, origin);
			else return;
		}
		recordAsyncArrowParametersError(at) {
			const { stack } = this;
			let i = stack.length - 1;
			let scope = stack[i];
			while (scope.canBeArrowParameterDeclaration()) {
				if (scope.type === 2) scope.recordDeclarationError(Errors.AwaitBindingIdentifier, at);
				scope = stack[--i];
			}
		}
		validateAsPattern() {
			const { stack } = this;
			const currentScope = stack[stack.length - 1];
			if (!currentScope.canBeArrowParameterDeclaration()) return;
			currentScope.iterateErrors(([toParseError, loc]) => {
				this.parser.raise(toParseError, loc);
				let i = stack.length - 2;
				let scope = stack[i];
				while (scope.canBeArrowParameterDeclaration()) {
					scope.clearDeclarationError(loc.index);
					scope = stack[--i];
				}
			});
		}
	};
	function newParameterDeclarationScope() {
		return new ExpressionScope(3);
	}
	function newArrowHeadScope() {
		return new ArrowHeadParsingScope(1);
	}
	function newAsyncArrowScope() {
		return new ArrowHeadParsingScope(2);
	}
	function newExpressionScope() {
		return new ExpressionScope();
	}
	var UtilParser = class extends Tokenizer {
		addExtra(node, key, value, enumerable = true) {
			if (!node) return;
			let { extra } = node;
			if (extra == null) {
				extra = {};
				node.extra = extra;
			}
			if (enumerable) extra[key] = value;
			else Object.defineProperty(extra, key, {
				enumerable,
				value
			});
		}
		isContextual(token) {
			return this.state.type === token && !this.state.containsEsc;
		}
		isUnparsedContextual(nameStart, name) {
			if (this.input.startsWith(name, nameStart)) {
				const nextCh = this.input.charCodeAt(nameStart + name.length);
				return !(isIdentifierChar(nextCh) || (nextCh & 64512) === 55296);
			}
			return false;
		}
		isLookaheadContextual(name) {
			const next = this.nextTokenStart();
			return this.isUnparsedContextual(next, name);
		}
		eatContextual(token) {
			if (this.isContextual(token)) {
				this.next();
				return true;
			}
			return false;
		}
		expectContextual(token, toParseError) {
			if (!this.eatContextual(token)) {
				if (toParseError != null) throw this.raise(toParseError, this.state.startLoc);
				this.unexpected(null, token);
			}
		}
		canInsertSemicolon() {
			return this.match(140) || this.match(8) || this.hasPrecedingLineBreak();
		}
		hasPrecedingLineBreak() {
			return hasNewLine(this.input, this.offsetToSourcePos(this.state.lastTokEndLoc.index), this.state.start);
		}
		hasFollowingLineBreak() {
			return hasNewLine(this.input, this.state.end, this.nextTokenStart());
		}
		isLineTerminator() {
			return this.eat(13) || this.canInsertSemicolon();
		}
		semicolon(allowAsi = true) {
			if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
			this.raise(Errors.MissingSemicolon, this.state.lastTokEndLoc);
		}
		expect(type, loc) {
			if (!this.eat(type)) this.unexpected(loc, type);
		}
		tryParse(fn, oldState = this.state.clone()) {
			const abortSignal = { node: null };
			try {
				const node = fn((node = null) => {
					abortSignal.node = node;
					throw abortSignal;
				});
				if (this.state.errors.length > oldState.errors.length) {
					const failState = this.state;
					this.state = oldState;
					this.state.tokensLength = failState.tokensLength;
					return {
						node,
						error: failState.errors[oldState.errors.length],
						thrown: false,
						aborted: false,
						failState
					};
				}
				return {
					node,
					error: null,
					thrown: false,
					aborted: false,
					failState: null
				};
			} catch (error) {
				const failState = this.state;
				this.state = oldState;
				if (error instanceof SyntaxError) return {
					node: null,
					error,
					thrown: true,
					aborted: false,
					failState
				};
				if (error === abortSignal) return {
					node: abortSignal.node,
					error: null,
					thrown: false,
					aborted: true,
					failState
				};
				throw error;
			}
		}
		checkExpressionErrors(refExpressionErrors, andThrow) {
			if (!refExpressionErrors) return false;
			const { shorthandAssignLoc, doubleProtoLoc, privateKeyLoc, optionalParametersLoc, voidPatternLoc } = refExpressionErrors;
			const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc || !!voidPatternLoc;
			if (!andThrow) return hasErrors;
			if (shorthandAssignLoc != null) this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
			if (doubleProtoLoc != null) this.raise(Errors.DuplicateProto, doubleProtoLoc);
			if (privateKeyLoc != null) this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
			if (optionalParametersLoc != null) this.unexpected(optionalParametersLoc);
			if (voidPatternLoc != null) this.raise(Errors.InvalidCoverDiscardElement, voidPatternLoc);
		}
		isLiteralPropertyName() {
			return tokenIsLiteralPropertyName(this.state.type);
		}
		isPrivateName(node) {
			return node.type === "PrivateName";
		}
		getPrivateNameSV(node) {
			return node.id.name;
		}
		hasPropertyAsPrivateName(node) {
			return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property);
		}
		isObjectProperty(node) {
			return node.type === "ObjectProperty";
		}
		isObjectMethod(node) {
			return node.type === "ObjectMethod";
		}
		initializeScopes(inModule = this.options.sourceType === "module") {
			const oldLabels = this.state.labels;
			this.state.labels = [];
			const oldExportedIdentifiers = this.exportedIdentifiers;
			this.exportedIdentifiers = /* @__PURE__ */ new Set();
			const oldInModule = this.inModule;
			this.inModule = inModule;
			const oldScope = this.scope;
			const ScopeHandler = this.getScopeHandler();
			this.scope = new ScopeHandler(this, inModule);
			const oldProdParam = this.prodParam;
			this.prodParam = new ProductionParameterHandler();
			const oldClassScope = this.classScope;
			this.classScope = new ClassScopeHandler(this);
			const oldExpressionScope = this.expressionScope;
			this.expressionScope = new ExpressionScopeHandler(this);
			return () => {
				this.state.labels = oldLabels;
				this.exportedIdentifiers = oldExportedIdentifiers;
				this.inModule = oldInModule;
				this.scope = oldScope;
				this.prodParam = oldProdParam;
				this.classScope = oldClassScope;
				this.expressionScope = oldExpressionScope;
			};
		}
		enterInitialScopes() {
			let paramFlags = 0;
			if (this.inModule || this.optionFlags & 1) paramFlags |= 2;
			if (this.optionFlags & 32) paramFlags |= 1;
			const isCommonJS = !this.inModule && this.options.sourceType === "commonjs";
			if (isCommonJS || this.optionFlags & 2) paramFlags |= 4;
			this.prodParam.enter(paramFlags);
			let scopeFlags = isCommonJS ? 514 : 1;
			if (this.optionFlags & 4) scopeFlags |= 512;
			this.scope.enter(scopeFlags);
		}
		checkDestructuringPrivate(refExpressionErrors) {
			const { privateKeyLoc } = refExpressionErrors;
			if (privateKeyLoc !== null) this.expectPlugin("destructuringPrivate", privateKeyLoc);
		}
	};
	var ExpressionErrors = class {
		constructor() {
			this.shorthandAssignLoc = null;
			this.doubleProtoLoc = null;
			this.privateKeyLoc = null;
			this.optionalParametersLoc = null;
			this.voidPatternLoc = null;
		}
	};
	var Node = class {
		constructor(parser, pos, loc) {
			this.type = "";
			this.start = pos;
			this.end = 0;
			this.loc = new SourceLocation(loc);
			if ((parser == null ? void 0 : parser.optionFlags) & 128) this.range = [pos, 0];
			if (parser != null && parser.filename) this.loc.filename = parser.filename;
		}
	};
	const NodePrototype = Node.prototype;
	NodePrototype.__clone = function() {
		const newNode = new Node(void 0, this.start, this.loc.start);
		const keys = Object.keys(this);
		for (let i = 0, length = keys.length; i < length; i++) {
			const key = keys[i];
			if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") newNode[key] = this[key];
		}
		return newNode;
	};
	var NodeUtils = class extends UtilParser {
		startNode() {
			const loc = this.state.startLoc;
			return new Node(this, loc.index, loc);
		}
		startNodeAt(loc) {
			return new Node(this, loc.index, loc);
		}
		startNodeAtNode(type) {
			return this.startNodeAt(type.loc.start);
		}
		finishNode(node, type) {
			return this.finishNodeAt(node, type, this.state.lastTokEndLoc);
		}
		finishNodeAt(node, type, endLoc) {
			node.type = type;
			node.end = endLoc.index;
			node.loc.end = endLoc;
			if (this.optionFlags & 128) node.range[1] = endLoc.index;
			if (this.optionFlags & 4096) this.processComment(node);
			return node;
		}
		resetStartLocation(node, startLoc) {
			node.start = startLoc.index;
			node.loc.start = startLoc;
			if (this.optionFlags & 128) node.range[0] = startLoc.index;
		}
		resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
			node.end = endLoc.index;
			node.loc.end = endLoc;
			if (this.optionFlags & 128) node.range[1] = endLoc.index;
		}
		resetStartLocationFromNode(node, locationNode) {
			this.resetStartLocation(node, locationNode.loc.start);
		}
		castNodeTo(node, type) {
			node.type = type;
			return node;
		}
		cloneIdentifier(node) {
			const { type, start, end, loc, range, name } = node;
			const cloned = Object.create(NodePrototype);
			cloned.type = type;
			cloned.start = start;
			cloned.end = end;
			cloned.loc = loc;
			cloned.range = range;
			cloned.name = name;
			if (node.extra) cloned.extra = node.extra;
			return cloned;
		}
		cloneStringLiteral(node) {
			const { type, start, end, loc, range, extra } = node;
			const cloned = Object.create(NodePrototype);
			cloned.type = type;
			cloned.start = start;
			cloned.end = end;
			cloned.loc = loc;
			cloned.range = range;
			cloned.extra = extra;
			cloned.value = node.value;
			return cloned;
		}
	};
	const unwrapParenthesizedExpression = (node) => {
		return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
	};
	var LValParser = class extends NodeUtils {
		toAssignable(node, isLHS = false) {
			var _node$extra, _node$extra3;
			let parenthesized = void 0;
			if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {
				parenthesized = unwrapParenthesizedExpression(node);
				if (isLHS) {
					if (parenthesized.type === "Identifier") this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, node);
					else if (parenthesized.type !== "CallExpression" && parenthesized.type !== "MemberExpression" && !this.isOptionalMemberExpression(parenthesized)) this.raise(Errors.InvalidParenthesizedAssignment, node);
				} else this.raise(Errors.InvalidParenthesizedAssignment, node);
			}
			switch (node.type) {
				case "Identifier":
				case "ObjectPattern":
				case "ArrayPattern":
				case "AssignmentPattern":
				case "RestElement":
				case "VoidPattern": break;
				case "ObjectExpression":
					this.castNodeTo(node, "ObjectPattern");
					for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
						var _node$extra2;
						const prop = node.properties[i];
						const isLast = i === last;
						this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
						if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) this.raise(Errors.RestTrailingComma, node.extra.trailingCommaLoc);
					}
					break;
				case "ObjectProperty": {
					const { key, value } = node;
					if (this.isPrivateName(key)) this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
					this.toAssignable(value, isLHS);
					break;
				}
				case "SpreadElement": throw new Error("Internal @babel/parser error (this is a bug, please report it). SpreadElement should be converted by .toAssignable's caller.");
				case "ArrayExpression":
					this.castNodeTo(node, "ArrayPattern");
					this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
					break;
				case "AssignmentExpression":
					if (node.operator !== "=") this.raise(Errors.MissingEqInAssignment, node.left.loc.end);
					this.castNodeTo(node, "AssignmentPattern");
					delete node.operator;
					if (node.left.type === "VoidPattern") this.raise(Errors.VoidPatternInitializer, node.left);
					this.toAssignable(node.left, isLHS);
					break;
				case "ParenthesizedExpression": this.toAssignable(parenthesized, isLHS);
			}
		}
		toAssignableObjectExpressionProp(prop, isLast, isLHS) {
			if (prop.type === "ObjectMethod") this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, prop.key);
			else if (prop.type === "SpreadElement") {
				this.castNodeTo(prop, "RestElement");
				const arg = prop.argument;
				this.checkToRestConversion(arg, false);
				this.toAssignable(arg, isLHS);
				if (!isLast) this.raise(Errors.RestTrailingComma, prop);
			} else this.toAssignable(prop, isLHS);
		}
		toAssignableList(exprList, trailingCommaLoc, isLHS) {
			const end = exprList.length - 1;
			for (let i = 0; i <= end; i++) {
				const elt = exprList[i];
				if (!elt) continue;
				this.toAssignableListItem(exprList, i, isLHS);
				if (elt.type === "RestElement") {
					if (i < end) this.raise(Errors.RestTrailingComma, elt);
					else if (trailingCommaLoc) this.raise(Errors.RestTrailingComma, trailingCommaLoc);
				}
			}
		}
		toAssignableListItem(exprList, index, isLHS) {
			const node = exprList[index];
			if (node.type === "SpreadElement") {
				this.castNodeTo(node, "RestElement");
				const arg = node.argument;
				this.checkToRestConversion(arg, true);
				this.toAssignable(arg, isLHS);
			} else this.toAssignable(node, isLHS);
		}
		isAssignable(node, isBinding) {
			switch (node.type) {
				case "Identifier":
				case "ObjectPattern":
				case "ArrayPattern":
				case "AssignmentPattern":
				case "RestElement":
				case "VoidPattern": return true;
				case "ObjectExpression": {
					const last = node.properties.length - 1;
					return node.properties.every((prop, i) => {
						return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop);
					});
				}
				case "ObjectProperty": return this.isAssignable(node.value);
				case "SpreadElement": return this.isAssignable(node.argument);
				case "ArrayExpression": return node.elements.every((element) => element === null || this.isAssignable(element));
				case "AssignmentExpression": return node.operator === "=";
				case "ParenthesizedExpression": return this.isAssignable(node.expression);
				case "MemberExpression":
				case "OptionalMemberExpression": return !isBinding;
				default: return false;
			}
		}
		toReferencedList(exprList, isParenthesizedExpr) {
			return exprList;
		}
		toReferencedListDeep(exprList, isParenthesizedExpr) {
			this.toReferencedList(exprList, isParenthesizedExpr);
			for (const expr of exprList) if ((expr == null ? void 0 : expr.type) === "ArrayExpression") this.toReferencedListDeep(expr.elements);
		}
		parseSpread(refExpressionErrors) {
			const node = this.startNode();
			this.next();
			node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, void 0);
			return this.finishNode(node, "SpreadElement");
		}
		parseRestBinding() {
			const node = this.startNode();
			this.next();
			const argument = this.parseBindingAtom();
			if (argument.type === "VoidPattern") this.raise(Errors.UnexpectedVoidPattern, argument);
			node.argument = argument;
			return this.finishNode(node, "RestElement");
		}
		parseBindingAtom() {
			switch (this.state.type) {
				case 0: {
					const node = this.startNode();
					this.next();
					node.elements = this.parseBindingList(3, 93, 1);
					return this.finishNode(node, "ArrayPattern");
				}
				case 5: return this.parseObjectLike(8, true);
				case 88: return this.parseVoidPattern(null);
			}
			return this.parseIdentifier();
		}
		parseBindingList(close, closeCharCode, flags) {
			const allowEmpty = flags & 1;
			const elts = [];
			let first = true;
			while (!this.eat(close)) {
				if (first) first = false;
				else this.expect(12);
				if (allowEmpty && this.match(12)) elts.push(null);
				else if (this.eat(close)) break;
				else if (this.match(21)) {
					let rest = this.parseRestBinding();
					if (this.hasPlugin("flow") || flags & 2) rest = this.parseFunctionParamType(rest);
					elts.push(rest);
					if (!this.checkCommaAfterRest(closeCharCode)) {
						this.expect(close);
						break;
					}
				} else {
					const decorators = [];
					if (flags & 2) {
						if (this.match(26) && this.hasPlugin("decorators")) this.raise(Errors.UnsupportedParameterDecorator, this.state.startLoc);
						while (this.match(26)) decorators.push(this.parseDecorator());
					}
					elts.push(this.parseBindingElement(flags, decorators));
				}
			}
			return elts;
		}
		parseBindingRestProperty(prop) {
			this.next();
			if (this.hasPlugin("discardBinding") && this.match(88)) {
				prop.argument = this.parseVoidPattern(null);
				this.raise(Errors.UnexpectedVoidPattern, prop.argument);
			} else prop.argument = this.parseIdentifier();
			this.checkCommaAfterRest(125);
			return this.finishNode(prop, "RestElement");
		}
		parseBindingProperty() {
			const { type, startLoc } = this.state;
			if (type === 21) return this.parseBindingRestProperty(this.startNode());
			const prop = this.startNode();
			if (type === 139) {
				this.expectPlugin("destructuringPrivate", startLoc);
				this.classScope.usePrivateName(this.state.value, startLoc);
				prop.key = this.parsePrivateName();
			} else this.parsePropertyName(prop);
			prop.method = false;
			return this.parseObjPropValue(prop, startLoc, false, false, true, false);
		}
		parseBindingElement(flags, decorators) {
			const left = this.parseMaybeDefault();
			if (this.hasPlugin("flow") || flags & 2) this.parseFunctionParamType(left);
			if (decorators.length) {
				left.decorators = decorators;
				this.resetStartLocationFromNode(left, decorators[0]);
			}
			return this.parseMaybeDefault(left.loc.start, left);
		}
		parseFunctionParamType(param) {
			return param;
		}
		parseMaybeDefault(startLoc, left) {
			startLoc != null || (startLoc = this.state.startLoc);
			left = left != null ? left : this.parseBindingAtom();
			if (!this.eat(29)) return left;
			const node = this.startNodeAt(startLoc);
			if (left.type === "VoidPattern") this.raise(Errors.VoidPatternInitializer, left);
			node.left = left;
			node.right = this.parseMaybeAssignAllowIn();
			return this.finishNode(node, "AssignmentPattern");
		}
		isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {
			switch (type) {
				case "AssignmentPattern": return "left";
				case "RestElement": return "argument";
				case "ObjectProperty": return "value";
				case "ParenthesizedExpression": return "expression";
				case "ArrayPattern": return "elements";
				case "ObjectPattern": return "properties";
				case "VoidPattern": return true;
				case "CallExpression": if (!disallowCallExpression && !this.state.strict && this.optionFlags & 8192) return true;
			}
			return false;
		}
		isOptionalMemberExpression(expression) {
			return expression.type === "OptionalMemberExpression";
		}
		checkLVal(expression, ancestor, binding = 64, checkClashes = false, strictModeChanged = false, hasParenthesizedAncestor = false, disallowCallExpression = false) {
			var _expression$extra;
			const type = expression.type;
			if (this.isObjectMethod(expression)) return;
			const isOptionalMemberExpression = this.isOptionalMemberExpression(expression);
			if (isOptionalMemberExpression || type === "MemberExpression") {
				if (isOptionalMemberExpression) {
					this.expectPlugin("optionalChainingAssign", expression.loc.start);
					if (ancestor.type !== "AssignmentExpression") this.raise(Errors.InvalidLhsOptionalChaining, expression, { ancestor });
				}
				if (binding !== 64) this.raise(Errors.InvalidPropertyBindingPattern, expression);
				return;
			}
			if (type === "Identifier") {
				this.checkIdentifier(expression, binding, strictModeChanged);
				const { name } = expression;
				if (checkClashes) {
					if (checkClashes.has(name)) this.raise(Errors.ParamDupe, expression);
					else checkClashes.add(name);
				}
				return;
			} else if (type === "VoidPattern" && ancestor.type === "CatchClause") this.raise(Errors.VoidPatternCatchClauseParam, expression);
			const unwrappedExpression = unwrapParenthesizedExpression(expression);
			disallowCallExpression || (disallowCallExpression = unwrappedExpression.type === "CallExpression" && (unwrappedExpression.callee.type === "Import" || unwrappedExpression.callee.type === "Super"));
			const validity = this.isValidLVal(type, disallowCallExpression, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
			if (validity === true) return;
			if (validity === false) {
				const ParseErrorClass = binding === 64 ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
				this.raise(ParseErrorClass, expression, { ancestor });
				return;
			}
			let key, isParenthesizedExpression;
			if (typeof validity === "string") {
				key = validity;
				isParenthesizedExpression = type === "ParenthesizedExpression";
			} else [key, isParenthesizedExpression] = validity;
			const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" ? { type } : ancestor;
			const val = expression[key];
			if (Array.isArray(val)) {
				for (const child of val) if (child) this.checkLVal(child, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, true);
			} else if (val) this.checkLVal(val, nextAncestor, binding, checkClashes, strictModeChanged, isParenthesizedExpression, disallowCallExpression);
		}
		checkIdentifier(at, bindingType, strictModeChanged = false) {
			if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
				if (bindingType === 64) this.raise(Errors.StrictEvalArguments, at, { referenceName: at.name });
				else this.raise(Errors.StrictEvalArgumentsBinding, at, { bindingName: at.name });
			}
			if (bindingType & 8192 && at.name === "let") this.raise(Errors.LetInLexicalBinding, at);
			if (!(bindingType & 64)) this.declareNameFromIdentifier(at, bindingType);
		}
		declareNameFromIdentifier(identifier, binding) {
			this.scope.declareName(identifier.name, binding, identifier.loc.start);
		}
		checkToRestConversion(node, allowPattern) {
			switch (node.type) {
				case "ParenthesizedExpression":
					this.checkToRestConversion(node.expression, allowPattern);
					break;
				case "Identifier":
				case "MemberExpression": break;
				case "ArrayExpression":
				case "ObjectExpression": if (allowPattern) break;
				default: this.raise(Errors.InvalidRestAssignmentPattern, node);
			}
		}
		checkCommaAfterRest(close) {
			if (!this.match(12)) return false;
			this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, this.state.startLoc);
			return true;
		}
	};
	const keywordAndTSRelationalOperator = /in(?:stanceof)?|as|satisfies/y;
	function nonNull(x) {
		if (x == null) throw new Error(`Unexpected ${x} value.`);
		return x;
	}
	function assert(x) {
		if (!x) throw new Error("Assert fail");
	}
	const TSErrors = ParseErrorEnum`typescript`({
		AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
		AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
		AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
		AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
		AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
		ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
		ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
		ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
		ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
		DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
		DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
		DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
		DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
		DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
		EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
		EmptyTypeArguments: "Type argument list cannot be empty.",
		EmptyTypeParameters: "Type parameter list cannot be empty.",
		ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
		ImportAliasHasImportType: "An import alias can not use 'import type'.",
		ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
		IncompatibleModifiers: ({ modifiers }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
		IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
		IndexSignatureHasAccessibility: ({ modifier }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
		IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
		IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
		IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
		InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
		InvalidHeritageClauseType: ({ token }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
		InvalidModifierOnAwaitUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on an await using declaration.`,
		InvalidModifierOnTypeMember: ({ modifier }) => `'${modifier}' modifier cannot appear on a type member.`,
		InvalidModifierOnTypeParameter: ({ modifier }) => `'${modifier}' modifier cannot appear on a type parameter.`,
		InvalidModifierOnTypeParameterPositions: ({ modifier }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
		InvalidModifierOnUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on a using declaration.`,
		InvalidModifiersOrder: ({ orderedModifiers }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
		InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
		InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
		MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
		NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
		NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.",
		OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
		OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
		PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
		PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
		PrivateElementHasAccessibility: ({ modifier }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
		ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
		ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
		ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
		SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
		SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
		SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
		SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
		StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
		TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
		TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
		TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
		TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
		TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
		UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
		UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
		UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
		UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
		UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
		UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
		UnsupportedSignatureParameterKind: ({ type }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
		UsingDeclarationInAmbientContext: (kind) => `'${kind}' declarations are not allowed in ambient contexts.`
	});
	function keywordTypeFromName(value) {
		switch (value) {
			case "any": return "TSAnyKeyword";
			case "boolean": return "TSBooleanKeyword";
			case "bigint": return "TSBigIntKeyword";
			case "never": return "TSNeverKeyword";
			case "number": return "TSNumberKeyword";
			case "object": return "TSObjectKeyword";
			case "string": return "TSStringKeyword";
			case "symbol": return "TSSymbolKeyword";
			case "undefined": return "TSUndefinedKeyword";
			case "unknown": return "TSUnknownKeyword";
			default: return;
		}
	}
	function tsIsAccessModifier(modifier) {
		return modifier === "private" || modifier === "public" || modifier === "protected";
	}
	function tsIsVarianceAnnotations(modifier) {
		return modifier === "in" || modifier === "out";
	}
	var typescript = (superClass) => class TypeScriptParserMixin extends superClass {
		constructor(...args) {
			super(...args);
			this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
				allowedModifiers: ["in", "out"],
				disallowedModifiers: [
					"const",
					"public",
					"private",
					"protected",
					"readonly",
					"declare",
					"abstract",
					"override"
				],
				errorTemplate: TSErrors.InvalidModifierOnTypeParameter
			});
			this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
				allowedModifiers: ["const"],
				disallowedModifiers: ["in", "out"],
				errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
			});
			this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
				allowedModifiers: [
					"in",
					"out",
					"const"
				],
				disallowedModifiers: [
					"public",
					"private",
					"protected",
					"readonly",
					"declare",
					"abstract",
					"override"
				],
				errorTemplate: TSErrors.InvalidModifierOnTypeParameter
			});
		}
		getScopeHandler() {
			return TypeScriptScopeHandler;
		}
		tsIsIdentifier() {
			return tokenIsIdentifier(this.state.type);
		}
		tsTokenCanFollowModifier() {
			return this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(139) || this.isLiteralPropertyName();
		}
		tsNextTokenOnSameLineAndCanFollowModifier() {
			this.next();
			if (this.hasPrecedingLineBreak()) return false;
			return this.tsTokenCanFollowModifier();
		}
		tsNextTokenCanFollowModifier() {
			if (this.match(106)) {
				this.next();
				return this.tsTokenCanFollowModifier();
			}
			return this.tsNextTokenOnSameLineAndCanFollowModifier();
		}
		tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
			if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) return;
			const modifier = this.state.value;
			if (allowedModifiers.includes(modifier)) {
				if (hasSeenStaticModifier && this.match(106)) return;
				if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) return;
				if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) return modifier;
			}
		}
		tsParseModifiers({ allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate = TSErrors.InvalidModifierOnTypeMember }, modified) {
			const enforceOrder = (loc, modifier, before, after) => {
				if (modifier === before && modified[after]) this.raise(TSErrors.InvalidModifiersOrder, loc, { orderedModifiers: [before, after] });
			};
			const incompatible = (loc, modifier, mod1, mod2) => {
				if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) this.raise(TSErrors.IncompatibleModifiers, loc, { modifiers: [mod1, mod2] });
			};
			for (;;) {
				const { startLoc } = this.state;
				const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock, modified.static);
				if (!modifier) break;
				if (tsIsAccessModifier(modifier)) {
					if (modified.accessibility) this.raise(TSErrors.DuplicateAccessibilityModifier, startLoc, { modifier });
					else {
						enforceOrder(startLoc, modifier, modifier, "override");
						enforceOrder(startLoc, modifier, modifier, "static");
						enforceOrder(startLoc, modifier, modifier, "readonly");
						modified.accessibility = modifier;
					}
				} else if (tsIsVarianceAnnotations(modifier)) {
					if (modified[modifier]) this.raise(TSErrors.DuplicateModifier, startLoc, { modifier });
					modified[modifier] = true;
					enforceOrder(startLoc, modifier, "in", "out");
				} else {
					if (hasOwnProperty.call(modified, modifier)) this.raise(TSErrors.DuplicateModifier, startLoc, { modifier });
					else {
						enforceOrder(startLoc, modifier, "static", "readonly");
						enforceOrder(startLoc, modifier, "static", "override");
						enforceOrder(startLoc, modifier, "override", "readonly");
						enforceOrder(startLoc, modifier, "abstract", "override");
						incompatible(startLoc, modifier, "declare", "override");
						incompatible(startLoc, modifier, "static", "abstract");
					}
					modified[modifier] = true;
				}
				if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) this.raise(errorTemplate, startLoc, { modifier });
			}
		}
		tsIsListTerminator(kind) {
			switch (kind) {
				case "EnumMembers":
				case "TypeMembers": return this.match(8);
				case "HeritageClauseElement": return this.match(5);
				case "TupleElementTypes": return this.match(3);
				case "TypeParametersOrArguments": return this.match(48);
			}
		}
		tsParseList(kind, parseElement) {
			const result = [];
			while (!this.tsIsListTerminator(kind)) result.push(parseElement());
			return result;
		}
		tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
			return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
		}
		tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
			const result = [];
			let trailingCommaPos = -1;
			for (;;) {
				if (this.tsIsListTerminator(kind)) break;
				trailingCommaPos = -1;
				const element = parseElement();
				if (element == null) return;
				result.push(element);
				if (this.eat(12)) {
					trailingCommaPos = this.state.lastTokStartLoc.index;
					continue;
				}
				if (this.tsIsListTerminator(kind)) break;
				if (expectSuccess) this.expect(12);
				return;
			}
			if (refTrailingCommaPos) refTrailingCommaPos.value = trailingCommaPos;
			return result;
		}
		tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
			if (!skipFirstToken) {
				if (bracket) this.expect(0);
				else this.expect(47);
			}
			const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
			if (bracket) this.expect(3);
			else this.expect(48);
			return result;
		}
		tsParseImportType() {
			const node = this.startNode();
			this.expect(83);
			this.expect(10);
			if (!this.match(134)) {
				this.raise(TSErrors.UnsupportedImportTypeArgument, this.state.startLoc);
				node.argument = super.parseExprAtom();
			} else node.argument = this.parseStringLiteral(this.state.value);
			if (this.eat(12)) node.options = this.tsParseImportTypeOptions();
			else node.options = null;
			this.expect(11);
			if (this.eat(16)) node.qualifier = this.tsParseEntityName(3);
			if (this.match(47)) node.typeParameters = this.tsParseTypeArguments();
			return this.finishNode(node, "TSImportType");
		}
		tsParseImportTypeOptions() {
			const node = this.startNode();
			this.expect(5);
			const withProperty = this.startNode();
			if (this.isContextual(76)) {
				withProperty.method = false;
				withProperty.key = this.parseIdentifier(true);
				withProperty.computed = false;
				withProperty.shorthand = false;
			} else this.unexpected(null, 76);
			this.expect(14);
			withProperty.value = this.tsParseImportTypeWithPropertyValue();
			node.properties = [this.finishObjectProperty(withProperty)];
			this.eat(12);
			this.expect(8);
			return this.finishNode(node, "ObjectExpression");
		}
		tsParseImportTypeWithPropertyValue() {
			const node = this.startNode();
			const properties = [];
			this.expect(5);
			while (!this.match(8)) {
				const type = this.state.type;
				if (tokenIsIdentifier(type) || type === 134) properties.push(super.parsePropertyDefinition(null));
				else this.unexpected();
				this.eat(12);
			}
			node.properties = properties;
			this.next();
			return this.finishNode(node, "ObjectExpression");
		}
		tsParseEntityName(flags) {
			let entity;
			if (flags & 1 && this.match(78)) {
				if (flags & 2) entity = this.parseIdentifier(true);
				else {
					const node = this.startNode();
					this.next();
					entity = this.finishNode(node, "ThisExpression");
				}
			} else entity = this.parseIdentifier(!!(flags & 1));
			while (this.eat(16)) {
				const node = this.startNodeAtNode(entity);
				node.left = entity;
				node.right = this.parseIdentifier(!!(flags & 1));
				entity = this.finishNode(node, "TSQualifiedName");
			}
			return entity;
		}
		tsParseTypeReference() {
			const node = this.startNode();
			node.typeName = this.tsParseEntityName(1);
			if (!this.hasPrecedingLineBreak() && this.match(47)) node.typeParameters = this.tsParseTypeArguments();
			return this.finishNode(node, "TSTypeReference");
		}
		tsParseThisTypePredicate(lhs) {
			this.next();
			const node = this.startNodeAtNode(lhs);
			node.parameterName = lhs;
			node.typeAnnotation = this.tsParseTypeAnnotation(false);
			node.asserts = false;
			return this.finishNode(node, "TSTypePredicate");
		}
		tsParseThisTypeNode() {
			const node = this.startNode();
			this.next();
			return this.finishNode(node, "TSThisType");
		}
		tsParseTypeQuery() {
			const node = this.startNode();
			this.expect(87);
			if (this.match(83)) node.exprName = this.tsParseImportType();
			else node.exprName = this.tsParseEntityName(3);
			if (!this.hasPrecedingLineBreak() && this.match(47)) node.typeParameters = this.tsParseTypeArguments();
			return this.finishNode(node, "TSTypeQuery");
		}
		tsParseTypeParameter(parseModifiers) {
			const node = this.startNode();
			parseModifiers(node);
			node.name = this.tsParseTypeParameterName();
			node.constraint = this.tsEatThenParseType(81);
			node.default = this.tsEatThenParseType(29);
			return this.finishNode(node, "TSTypeParameter");
		}
		tsTryParseTypeParameters(parseModifiers) {
			if (this.match(47)) return this.tsParseTypeParameters(parseModifiers);
		}
		tsParseTypeParameters(parseModifiers) {
			const node = this.startNode();
			if (this.match(47) || this.match(143)) this.next();
			else this.unexpected();
			const refTrailingCommaPos = { value: -1 };
			node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
			if (node.params.length === 0) this.raise(TSErrors.EmptyTypeParameters, node);
			if (refTrailingCommaPos.value !== -1) this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
			return this.finishNode(node, "TSTypeParameterDeclaration");
		}
		tsFillSignature(returnToken, signature) {
			const returnTokenRequired = returnToken === 19;
			const paramsKey = "parameters";
			const returnTypeKey = "typeAnnotation";
			signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
			this.expect(10);
			signature[paramsKey] = this.tsParseBindingListForSignature();
			if (returnTokenRequired) signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
			else if (this.match(returnToken)) signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
		}
		tsParseBindingListForSignature() {
			const list = super.parseBindingList(11, 41, 2);
			for (const pattern of list) {
				const { type } = pattern;
				if (type === "AssignmentPattern" || type === "TSParameterProperty") this.raise(TSErrors.UnsupportedSignatureParameterKind, pattern, { type });
			}
			return list;
		}
		tsParseTypeMemberSemicolon() {
			if (!this.eat(12) && !this.isLineTerminator()) this.expect(13);
		}
		tsParseSignatureMember(kind, node) {
			this.tsFillSignature(14, node);
			this.tsParseTypeMemberSemicolon();
			return this.finishNode(node, kind);
		}
		tsIsUnambiguouslyIndexSignature() {
			this.next();
			if (tokenIsIdentifier(this.state.type)) {
				this.next();
				return this.match(14);
			}
			return false;
		}
		tsTryParseIndexSignature(node) {
			if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) return;
			this.expect(0);
			const id = this.parseIdentifier();
			id.typeAnnotation = this.tsParseTypeAnnotation();
			this.resetEndLocation(id);
			this.expect(3);
			node.parameters = [id];
			const type = this.tsTryParseTypeAnnotation();
			if (type) node.typeAnnotation = type;
			this.tsParseTypeMemberSemicolon();
			return this.finishNode(node, "TSIndexSignature");
		}
		tsParsePropertyOrMethodSignature(node, readonly) {
			if (this.eat(17)) node.optional = true;
			if (this.match(10) || this.match(47)) {
				if (readonly) this.raise(TSErrors.ReadonlyForMethodSignature, node);
				const method = node;
				if (method.kind && this.match(47)) this.raise(TSErrors.AccessorCannotHaveTypeParameters, this.state.curPosition());
				this.tsFillSignature(14, method);
				this.tsParseTypeMemberSemicolon();
				const paramsKey = "parameters";
				const returnTypeKey = "typeAnnotation";
				if (method.kind === "get") {
					if (method[paramsKey].length > 0) {
						this.raise(Errors.BadGetterArity, this.state.curPosition());
						if (this.isThisParam(method[paramsKey][0])) this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
					}
				} else if (method.kind === "set") {
					if (method[paramsKey].length !== 1) this.raise(Errors.BadSetterArity, this.state.curPosition());
					else {
						const firstParameter = method[paramsKey][0];
						if (this.isThisParam(firstParameter)) this.raise(TSErrors.AccessorCannotDeclareThisParameter, this.state.curPosition());
						if (firstParameter.type === "Identifier" && firstParameter.optional) this.raise(TSErrors.SetAccessorCannotHaveOptionalParameter, this.state.curPosition());
						if (firstParameter.type === "RestElement") this.raise(TSErrors.SetAccessorCannotHaveRestParameter, this.state.curPosition());
					}
					if (method[returnTypeKey]) this.raise(TSErrors.SetAccessorCannotHaveReturnType, method[returnTypeKey]);
				} else method.kind = "method";
				return this.finishNode(method, "TSMethodSignature");
			} else {
				const property = node;
				if (readonly) property.readonly = true;
				const type = this.tsTryParseTypeAnnotation();
				if (type) property.typeAnnotation = type;
				this.tsParseTypeMemberSemicolon();
				return this.finishNode(property, "TSPropertySignature");
			}
		}
		tsParseTypeMember() {
			const node = this.startNode();
			if (this.match(10) || this.match(47)) return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
			if (this.match(77)) {
				const id = this.startNode();
				this.next();
				if (this.match(10) || this.match(47)) return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
				else {
					node.key = this.createIdentifier(id, "new");
					return this.tsParsePropertyOrMethodSignature(node, false);
				}
			}
			this.tsParseModifiers({
				allowedModifiers: ["readonly"],
				disallowedModifiers: [
					"declare",
					"abstract",
					"private",
					"protected",
					"public",
					"static",
					"override"
				]
			}, node);
			const idx = this.tsTryParseIndexSignature(node);
			if (idx) return idx;
			super.parsePropertyName(node);
			if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
				node.kind = node.key.name;
				super.parsePropertyName(node);
				if (!this.match(10) && !this.match(47)) this.unexpected(null, 10);
			}
			return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);
		}
		tsParseTypeLiteral() {
			const node = this.startNode();
			node.members = this.tsParseObjectTypeMembers();
			return this.finishNode(node, "TSTypeLiteral");
		}
		tsParseObjectTypeMembers() {
			this.expect(5);
			const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
			this.expect(8);
			return members;
		}
		tsIsStartOfMappedType() {
			this.next();
			if (this.eat(53)) return this.isContextual(122);
			if (this.isContextual(122)) this.next();
			if (!this.match(0)) return false;
			this.next();
			if (!this.tsIsIdentifier()) return false;
			this.next();
			return this.match(58);
		}
		tsParseMappedType() {
			const node = this.startNode();
			this.expect(5);
			if (this.match(53)) {
				node.readonly = this.state.value;
				this.next();
				this.expectContextual(122);
			} else if (this.eatContextual(122)) node.readonly = true;
			this.expect(0);
			const typeParameter = this.startNode();
			typeParameter.name = this.tsParseTypeParameterName();
			typeParameter.constraint = this.tsExpectThenParseType(58);
			node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
			node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
			this.expect(3);
			if (this.match(53)) {
				node.optional = this.state.value;
				this.next();
				this.expect(17);
			} else if (this.eat(17)) node.optional = true;
			node.typeAnnotation = this.tsTryParseType();
			this.semicolon();
			this.expect(8);
			return this.finishNode(node, "TSMappedType");
		}
		tsParseTupleType() {
			const node = this.startNode();
			node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
			let seenOptionalElement = false;
			node.elementTypes.forEach((elementNode) => {
				const { type } = elementNode;
				if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) this.raise(TSErrors.OptionalTypeBeforeRequired, elementNode);
				seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
			});
			return this.finishNode(node, "TSTupleType");
		}
		tsParseTupleElementType() {
			const restStartLoc = this.state.startLoc;
			const rest = this.eat(21);
			const { startLoc } = this.state;
			let labeled;
			let label;
			let optional;
			let type;
			const chAfterWord = tokenIsKeywordOrIdentifier(this.state.type) ? this.lookaheadCharCode() : null;
			if (chAfterWord === 58) {
				labeled = true;
				optional = false;
				label = this.parseIdentifier(true);
				this.expect(14);
				type = this.tsParseType();
			} else if (chAfterWord === 63) {
				optional = true;
				const wordName = this.state.value;
				const typeOrLabel = this.tsParseNonArrayType();
				if (this.lookaheadCharCode() === 58) {
					labeled = true;
					label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
					this.expect(17);
					this.expect(14);
					type = this.tsParseType();
				} else {
					labeled = false;
					type = typeOrLabel;
					this.expect(17);
				}
			} else {
				type = this.tsParseType();
				optional = this.eat(17);
				labeled = this.eat(14);
			}
			if (labeled) {
				let labeledNode;
				if (label) {
					labeledNode = this.startNodeAt(startLoc);
					labeledNode.optional = optional;
					labeledNode.label = label;
					labeledNode.elementType = type;
					if (this.eat(17)) {
						labeledNode.optional = true;
						this.raise(TSErrors.TupleOptionalAfterType, this.state.lastTokStartLoc);
					}
				} else {
					labeledNode = this.startNodeAt(startLoc);
					labeledNode.optional = optional;
					this.raise(TSErrors.InvalidTupleMemberLabel, type);
					labeledNode.label = type;
					labeledNode.elementType = this.tsParseType();
				}
				type = this.finishNode(labeledNode, "TSNamedTupleMember");
			} else if (optional) {
				const optionalTypeNode = this.startNodeAt(startLoc);
				optionalTypeNode.typeAnnotation = type;
				type = this.finishNode(optionalTypeNode, "TSOptionalType");
			}
			if (rest) {
				const restNode = this.startNodeAt(restStartLoc);
				restNode.typeAnnotation = type;
				type = this.finishNode(restNode, "TSRestType");
			}
			return type;
		}
		tsParseParenthesizedType() {
			const node = this.startNode();
			this.expect(10);
			node.typeAnnotation = this.tsParseType();
			this.expect(11);
			return this.finishNode(node, "TSParenthesizedType");
		}
		tsParseFunctionOrConstructorType(type, abstract) {
			const node = this.startNode();
			if (type === "TSConstructorType") {
				node.abstract = !!abstract;
				if (abstract) this.next();
				this.next();
			}
			this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
			return this.finishNode(node, type);
		}
		tsParseLiteralTypeNode() {
			const node = this.startNode();
			switch (this.state.type) {
				case 135:
				case 136:
				case 134:
				case 85:
				case 86:
					node.literal = super.parseExprAtom();
					break;
				default: this.unexpected();
			}
			return this.finishNode(node, "TSLiteralType");
		}
		tsParseTemplateLiteralType() {
			const node = this.startNode();
			node.literal = super.parseTemplate(false);
			return this.finishNode(node, "TSLiteralType");
		}
		parseTemplateSubstitution() {
			if (this.state.inType) return this.tsParseType();
			return super.parseTemplateSubstitution();
		}
		tsParseThisTypeOrThisTypePredicate() {
			const thisKeyword = this.tsParseThisTypeNode();
			if (this.isContextual(116) && !this.hasPrecedingLineBreak()) return this.tsParseThisTypePredicate(thisKeyword);
			else return thisKeyword;
		}
		tsParseNonArrayType() {
			switch (this.state.type) {
				case 134:
				case 135:
				case 136:
				case 85:
				case 86: return this.tsParseLiteralTypeNode();
				case 53:
					if (this.state.value === "-") {
						const node = this.startNode();
						const nextToken = this.lookahead();
						if (nextToken.type !== 135 && nextToken.type !== 136) this.unexpected();
						node.literal = this.parseMaybeUnary();
						return this.finishNode(node, "TSLiteralType");
					}
					break;
				case 78: return this.tsParseThisTypeOrThisTypePredicate();
				case 87: return this.tsParseTypeQuery();
				case 83: return this.tsParseImportType();
				case 5: return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
				case 0: return this.tsParseTupleType();
				case 10: return this.tsParseParenthesizedType();
				case 25:
				case 24: return this.tsParseTemplateLiteralType();
				default: {
					const { type } = this.state;
					if (tokenIsIdentifier(type) || type === 88 || type === 84) {
						const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
						if (nodeType !== void 0 && this.lookaheadCharCode() !== 46) {
							const node = this.startNode();
							this.next();
							return this.finishNode(node, nodeType);
						}
						return this.tsParseTypeReference();
					}
				}
			}
			throw this.unexpected();
		}
		tsParseArrayTypeOrHigher() {
			const { startLoc } = this.state;
			let type = this.tsParseNonArrayType();
			while (!this.hasPrecedingLineBreak() && this.eat(0)) if (this.match(3)) {
				const node = this.startNodeAt(startLoc);
				node.elementType = type;
				this.expect(3);
				type = this.finishNode(node, "TSArrayType");
			} else {
				const node = this.startNodeAt(startLoc);
				node.objectType = type;
				node.indexType = this.tsParseType();
				this.expect(3);
				type = this.finishNode(node, "TSIndexedAccessType");
			}
			return type;
		}
		tsParseTypeOperator() {
			const node = this.startNode();
			const operator = this.state.value;
			this.next();
			node.operator = operator;
			node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
			if (operator === "readonly") this.tsCheckTypeAnnotationForReadOnly(node);
			return this.finishNode(node, "TSTypeOperator");
		}
		tsCheckTypeAnnotationForReadOnly(node) {
			switch (node.typeAnnotation.type) {
				case "TSTupleType":
				case "TSArrayType": return;
				default: this.raise(TSErrors.UnexpectedReadonly, node);
			}
		}
		tsParseInferType() {
			const node = this.startNode();
			this.expectContextual(115);
			const typeParameter = this.startNode();
			typeParameter.name = this.tsParseTypeParameterName();
			typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
			node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
			return this.finishNode(node, "TSInferType");
		}
		tsParseConstraintForInferType() {
			if (this.eat(81)) {
				const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
				if (this.state.inDisallowConditionalTypesContext || !this.match(17)) return constraint;
			}
		}
		tsParseTypeOperatorOrHigher() {
			return tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc ? this.tsParseTypeOperator() : this.isContextual(115) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
		}
		tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
			const node = this.startNode();
			const hasLeadingOperator = this.eat(operator);
			const types = [];
			do
				types.push(parseConstituentType());
			while (this.eat(operator));
			if (types.length === 1 && !hasLeadingOperator) return types[0];
			node.types = types;
			return this.finishNode(node, kind);
		}
		tsParseIntersectionTypeOrHigher() {
			return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
		}
		tsParseUnionTypeOrHigher() {
			return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
		}
		tsIsStartOfFunctionType() {
			if (this.match(47)) return true;
			return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
		}
		tsSkipParameterStart() {
			if (tokenIsIdentifier(this.state.type) || this.match(78)) {
				this.next();
				return true;
			}
			if (this.match(5)) {
				const { errors } = this.state;
				const previousErrorCount = errors.length;
				try {
					this.parseObjectLike(8, true);
					return errors.length === previousErrorCount;
				} catch (_unused) {
					return false;
				}
			}
			if (this.match(0)) {
				this.next();
				const { errors } = this.state;
				const previousErrorCount = errors.length;
				try {
					super.parseBindingList(3, 93, 1);
					return errors.length === previousErrorCount;
				} catch (_unused2) {
					return false;
				}
			}
			return false;
		}
		tsIsUnambiguouslyStartOfFunctionType() {
			this.next();
			if (this.match(11) || this.match(21)) return true;
			if (this.tsSkipParameterStart()) {
				if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) return true;
				if (this.match(11)) {
					this.next();
					if (this.match(19)) return true;
				}
			}
			return false;
		}
		tsParseTypeOrTypePredicateAnnotation(returnToken) {
			return this.tsInType(() => {
				const t = this.startNode();
				this.expect(returnToken);
				const node = this.startNode();
				const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
				if (asserts && this.match(78)) {
					let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
					if (thisTypePredicate.type === "TSThisType") {
						node.parameterName = thisTypePredicate;
						node.asserts = true;
						node.typeAnnotation = null;
						thisTypePredicate = this.finishNode(node, "TSTypePredicate");
					} else {
						this.resetStartLocationFromNode(thisTypePredicate, node);
						thisTypePredicate.asserts = true;
					}
					t.typeAnnotation = thisTypePredicate;
					return this.finishNode(t, "TSTypeAnnotation");
				}
				const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
				if (!typePredicateVariable) {
					if (!asserts) return this.tsParseTypeAnnotation(false, t);
					node.parameterName = this.parseIdentifier();
					node.asserts = asserts;
					node.typeAnnotation = null;
					t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
					return this.finishNode(t, "TSTypeAnnotation");
				}
				const type = this.tsParseTypeAnnotation(false);
				node.parameterName = typePredicateVariable;
				node.typeAnnotation = type;
				node.asserts = asserts;
				t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
				return this.finishNode(t, "TSTypeAnnotation");
			});
		}
		tsTryParseTypeOrTypePredicateAnnotation() {
			if (this.match(14)) return this.tsParseTypeOrTypePredicateAnnotation(14);
		}
		tsTryParseTypeAnnotation() {
			if (this.match(14)) return this.tsParseTypeAnnotation();
		}
		tsTryParseType() {
			return this.tsEatThenParseType(14);
		}
		tsParseTypePredicatePrefix() {
			const id = this.parseIdentifier();
			if (this.isContextual(116) && !this.hasPrecedingLineBreak()) {
				this.next();
				return id;
			}
		}
		tsParseTypePredicateAsserts() {
			if (this.state.type !== 109) return false;
			const containsEsc = this.state.containsEsc;
			this.next();
			if (!tokenIsIdentifier(this.state.type) && !this.match(78)) return false;
			if (containsEsc) this.raise(Errors.InvalidEscapedReservedWord, this.state.lastTokStartLoc, { reservedWord: "asserts" });
			return true;
		}
		tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
			this.tsInType(() => {
				if (eatColon) this.expect(14);
				t.typeAnnotation = this.tsParseType();
			});
			return this.finishNode(t, "TSTypeAnnotation");
		}
		tsParseType() {
			assert(this.state.inType);
			const type = this.tsParseNonConditionalType();
			if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) return type;
			const node = this.startNodeAtNode(type);
			node.checkType = type;
			node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
			this.expect(17);
			node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
			this.expect(14);
			node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
			return this.finishNode(node, "TSConditionalType");
		}
		isAbstractConstructorSignature() {
			return this.isContextual(124) && this.isLookaheadContextual("new");
		}
		tsParseNonConditionalType() {
			if (this.tsIsStartOfFunctionType()) return this.tsParseFunctionOrConstructorType("TSFunctionType");
			if (this.match(77)) return this.tsParseFunctionOrConstructorType("TSConstructorType");
			else if (this.isAbstractConstructorSignature()) return this.tsParseFunctionOrConstructorType("TSConstructorType", true);
			return this.tsParseUnionTypeOrHigher();
		}
		tsParseTypeAssertion() {
			if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) this.raise(TSErrors.ReservedTypeAssertion, this.state.startLoc);
			const node = this.startNode();
			node.typeAnnotation = this.tsInType(() => {
				this.next();
				return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
			});
			this.expect(48);
			node.expression = this.parseMaybeUnary();
			return this.finishNode(node, "TSTypeAssertion");
		}
		tsParseHeritageClause(token) {
			const originalStartLoc = this.state.startLoc;
			const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
				const node = this.startNode();
				node.expression = this.tsParseEntityName(3);
				if (this.match(47)) node.typeParameters = this.tsParseTypeArguments();
				return this.finishNode(node, "TSExpressionWithTypeArguments");
			});
			if (!delimitedList.length) this.raise(TSErrors.EmptyHeritageClauseType, originalStartLoc, { token });
			return delimitedList;
		}
		tsParseInterfaceDeclaration(node, properties = {}) {
			if (this.hasFollowingLineBreak()) return null;
			this.expectContextual(129);
			if (properties.declare) node.declare = true;
			if (tokenIsIdentifier(this.state.type)) {
				node.id = this.parseIdentifier();
				this.checkIdentifier(node.id, 130);
			} else {
				node.id = null;
				this.raise(TSErrors.MissingInterfaceName, this.state.startLoc);
			}
			node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
			if (this.eat(81)) node.extends = this.tsParseHeritageClause("extends");
			const body = this.startNode();
			body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
			node.body = this.finishNode(body, "TSInterfaceBody");
			return this.finishNode(node, "TSInterfaceDeclaration");
		}
		tsParseTypeAliasDeclaration(node) {
			node.id = this.parseIdentifier();
			this.checkIdentifier(node.id, 2);
			node.typeAnnotation = this.tsInType(() => {
				node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
				this.expect(29);
				if (this.isContextual(114) && this.lookaheadCharCode() !== 46) {
					const node = this.startNode();
					this.next();
					return this.finishNode(node, "TSIntrinsicKeyword");
				}
				return this.tsParseType();
			});
			this.semicolon();
			return this.finishNode(node, "TSTypeAliasDeclaration");
		}
		tsInTopLevelContext(cb) {
			if (this.curContext() !== types.brace) {
				const oldContext = this.state.context;
				this.state.context = [oldContext[0]];
				try {
					return cb();
				} finally {
					this.state.context = oldContext;
				}
			} else return cb();
		}
		tsInType(cb) {
			const oldInType = this.state.inType;
			this.state.inType = true;
			try {
				return cb();
			} finally {
				this.state.inType = oldInType;
			}
		}
		tsInDisallowConditionalTypesContext(cb) {
			const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
			this.state.inDisallowConditionalTypesContext = true;
			try {
				return cb();
			} finally {
				this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
			}
		}
		tsInAllowConditionalTypesContext(cb) {
			const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
			this.state.inDisallowConditionalTypesContext = false;
			try {
				return cb();
			} finally {
				this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
			}
		}
		tsEatThenParseType(token) {
			if (this.match(token)) return this.tsNextThenParseType();
		}
		tsExpectThenParseType(token) {
			return this.tsInType(() => {
				this.expect(token);
				return this.tsParseType();
			});
		}
		tsNextThenParseType() {
			return this.tsInType(() => {
				this.next();
				return this.tsParseType();
			});
		}
		tsParseEnumMember() {
			const node = this.startNode();
			node.id = this.match(134) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
			if (this.eat(29)) node.initializer = super.parseMaybeAssignAllowIn();
			return this.finishNode(node, "TSEnumMember");
		}
		tsParseEnumDeclaration(node, properties = {}) {
			if (properties.const) node.const = true;
			if (properties.declare) node.declare = true;
			this.expectContextual(126);
			node.id = this.parseIdentifier();
			this.checkIdentifier(node.id, node.const ? 8971 : 8459);
			this.expect(5);
			node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
			this.expect(8);
			return this.finishNode(node, "TSEnumDeclaration");
		}
		tsParseEnumBody() {
			const node = this.startNode();
			this.expect(5);
			node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
			this.expect(8);
			return this.finishNode(node, "TSEnumBody");
		}
		tsParseModuleBlock() {
			const node = this.startNode();
			this.scope.enter(0);
			this.expect(5);
			super.parseBlockOrModuleBlockBody(node.body = [], void 0, true, 8);
			this.scope.exit();
			return this.finishNode(node, "TSModuleBlock");
		}
		tsParseModuleOrNamespaceDeclaration(node, nested = false) {
			node.id = this.parseIdentifier();
			if (!nested) this.checkIdentifier(node.id, 1024);
			if (this.eat(16)) {
				const inner = this.startNode();
				this.tsParseModuleOrNamespaceDeclaration(inner, true);
				node.body = inner;
			} else {
				this.scope.enter(1024);
				this.prodParam.enter(0);
				node.body = this.tsParseModuleBlock();
				this.prodParam.exit();
				this.scope.exit();
			}
			return this.finishNode(node, "TSModuleDeclaration");
		}
		tsParseAmbientExternalModuleDeclaration(node) {
			if (this.isContextual(112)) {
				node.kind = "global";
				node.global = true;
				node.id = this.parseIdentifier();
			} else if (this.match(134)) {
				node.kind = "module";
				node.id = super.parseStringLiteral(this.state.value);
			} else this.unexpected();
			if (this.match(5)) {
				this.scope.enter(1024);
				this.prodParam.enter(0);
				node.body = this.tsParseModuleBlock();
				this.prodParam.exit();
				this.scope.exit();
			} else this.semicolon();
			return this.finishNode(node, "TSModuleDeclaration");
		}
		tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier, isExport) {
			node.isExport = isExport || false;
			node.id = maybeDefaultIdentifier || this.parseIdentifier();
			this.checkIdentifier(node.id, 4096);
			this.expect(29);
			const moduleReference = this.tsParseModuleReference();
			if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") this.raise(TSErrors.ImportAliasHasImportType, moduleReference);
			node.moduleReference = moduleReference;
			this.semicolon();
			return this.finishNode(node, "TSImportEqualsDeclaration");
		}
		tsIsExternalModuleReference() {
			return this.isContextual(119) && this.lookaheadCharCode() === 40;
		}
		tsParseModuleReference() {
			return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(0);
		}
		tsParseExternalModuleReference() {
			const node = this.startNode();
			this.expectContextual(119);
			this.expect(10);
			if (!this.match(134)) this.unexpected();
			node.expression = super.parseExprAtom();
			this.expect(11);
			this.sawUnambiguousESM = true;
			return this.finishNode(node, "TSExternalModuleReference");
		}
		tsLookAhead(f) {
			const state = this.state.clone();
			const res = f();
			this.state = state;
			return res;
		}
		tsTryParseAndCatch(f) {
			const result = this.tryParse((abort) => f() || abort());
			if (result.aborted || !result.node) return;
			if (result.error) this.state = result.failState;
			return result.node;
		}
		tsTryParse(f) {
			const state = this.state.clone();
			const result = f();
			if (result !== void 0 && result !== false) return result;
			this.state = state;
		}
		tsTryParseDeclare(node) {
			if (this.isLineTerminator()) return;
			const startType = this.state.type;
			return this.tsInAmbientContext(() => {
				switch (startType) {
					case 68:
						node.declare = true;
						return super.parseFunctionStatement(node, false, false);
					case 80:
						node.declare = true;
						return this.parseClass(node, true, false);
					case 126: return this.tsParseEnumDeclaration(node, { declare: true });
					case 112: return this.tsParseAmbientExternalModuleDeclaration(node);
					case 100: if (this.state.containsEsc) return;
					case 75:
					case 74:
						if (!this.match(75) || !this.isLookaheadContextual("enum")) {
							node.declare = true;
							return this.parseVarStatement(node, this.state.value, true);
						}
						this.expect(75);
						return this.tsParseEnumDeclaration(node, {
							const: true,
							declare: true
						});
					case 107:
						if (this.isUsing()) {
							this.raise(TSErrors.InvalidModifierOnUsingDeclaration, this.state.startLoc, "declare");
							node.declare = true;
							return this.parseVarStatement(node, "using", true);
						}
						break;
					case 96:
						if (this.isAwaitUsing()) {
							this.raise(TSErrors.InvalidModifierOnAwaitUsingDeclaration, this.state.startLoc, "declare");
							node.declare = true;
							this.next();
							return this.parseVarStatement(node, "await using", true);
						}
						break;
					case 129: {
						const result = this.tsParseInterfaceDeclaration(node, { declare: true });
						if (result) return result;
					}
					default: if (tokenIsIdentifier(startType)) return this.tsParseDeclaration(node, this.state.type, true, null);
				}
			});
		}
		tsTryParseExportDeclaration() {
			return this.tsParseDeclaration(this.startNode(), this.state.type, true, null);
		}
		tsParseDeclaration(node, type, next, decorators) {
			switch (type) {
				case 124:
					if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) return this.tsParseAbstractDeclaration(node, decorators);
					break;
				case 127:
					if (this.tsCheckLineTerminator(next)) {
						if (this.match(134)) return this.tsParseAmbientExternalModuleDeclaration(node);
						else if (tokenIsIdentifier(this.state.type)) {
							node.kind = "module";
							return this.tsParseModuleOrNamespaceDeclaration(node);
						}
					}
					break;
				case 128:
					if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
						node.kind = "namespace";
						return this.tsParseModuleOrNamespaceDeclaration(node);
					}
					break;
				case 130: if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) return this.tsParseTypeAliasDeclaration(node);
			}
		}
		tsCheckLineTerminator(next) {
			if (next) {
				if (this.hasFollowingLineBreak()) return false;
				this.next();
				return true;
			}
			return !this.isLineTerminator();
		}
		tsTryParseGenericAsyncArrowFunction(startLoc) {
			if (!this.match(47)) return;
			const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
			this.state.maybeInArrowParameters = true;
			const res = this.tsTryParseAndCatch(() => {
				const node = this.startNodeAt(startLoc);
				node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
				super.parseFunctionParams(node);
				node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
				this.expect(19);
				return node;
			});
			this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
			if (!res) return;
			return super.parseArrowExpression(res, null, true);
		}
		tsParseTypeArgumentsInExpression() {
			if (this.reScan_lt() !== 47) return;
			return this.tsParseTypeArguments();
		}
		tsParseTypeArguments() {
			const node = this.startNode();
			node.params = this.tsInType(() => this.tsInTopLevelContext(() => {
				this.expect(47);
				return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
			}));
			if (node.params.length === 0) this.raise(TSErrors.EmptyTypeArguments, node);
			else if (!this.state.inType && this.curContext() === types.brace) this.reScan_lt_gt();
			this.expect(48);
			return this.finishNode(node, "TSTypeParameterInstantiation");
		}
		tsIsDeclarationStart() {
			return tokenIsTSDeclarationStart(this.state.type);
		}
		isExportDefaultSpecifier() {
			if (this.tsIsDeclarationStart()) return false;
			return super.isExportDefaultSpecifier();
		}
		parseBindingElement(flags, decorators) {
			const startLoc = decorators.length ? decorators[0].loc.start : this.state.startLoc;
			const modified = {};
			this.tsParseModifiers({ allowedModifiers: [
				"public",
				"private",
				"protected",
				"override",
				"readonly"
			] }, modified);
			const accessibility = modified.accessibility;
			const override = modified.override;
			const readonly = modified.readonly;
			if (!(flags & 4) && (accessibility || readonly || override)) this.raise(TSErrors.UnexpectedParameterModifier, startLoc);
			const left = this.parseMaybeDefault();
			if (flags & 2) this.parseFunctionParamType(left);
			const elt = this.parseMaybeDefault(left.loc.start, left);
			if (accessibility || readonly || override) {
				const pp = this.startNodeAt(startLoc);
				if (decorators.length) pp.decorators = decorators;
				if (accessibility) pp.accessibility = accessibility;
				if (readonly) pp.readonly = readonly;
				if (override) pp.override = override;
				if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") this.raise(TSErrors.UnsupportedParameterPropertyKind, pp);
				pp.parameter = elt;
				return this.finishNode(pp, "TSParameterProperty");
			}
			if (decorators.length) left.decorators = decorators;
			return elt;
		}
		isSimpleParameter(node) {
			return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
		}
		tsDisallowOptionalPattern(node) {
			for (const param of node.params) if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) this.raise(TSErrors.PatternIsOptional, param);
		}
		setArrowFunctionParameters(node, params, trailingCommaLoc) {
			super.setArrowFunctionParameters(node, params, trailingCommaLoc);
			this.tsDisallowOptionalPattern(node);
		}
		parseFunctionBodyAndFinish(node, type, isMethod = false) {
			if (this.match(14)) node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
			const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : void 0;
			if (bodilessType && !this.match(5) && this.isLineTerminator()) return this.finishNode(node, bodilessType);
			if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
				this.raise(TSErrors.DeclareFunctionHasImplementation, node);
				if (node.declare) return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
			}
			this.tsDisallowOptionalPattern(node);
			return super.parseFunctionBodyAndFinish(node, type, isMethod);
		}
		registerFunctionStatementId(node) {
			if (!node.body && node.id) this.checkIdentifier(node.id, 1024);
			else super.registerFunctionStatementId(node);
		}
		tsCheckForInvalidTypeCasts(items) {
			items.forEach((node) => {
				if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") this.raise(TSErrors.UnexpectedTypeAnnotation, node.typeAnnotation);
			});
		}
		toReferencedList(exprList, isInParens) {
			this.tsCheckForInvalidTypeCasts(exprList);
			return exprList;
		}
		parseArrayLike(close, isTuple, refExpressionErrors) {
			const node = super.parseArrayLike(close, isTuple, refExpressionErrors);
			if (node.type === "ArrayExpression") this.tsCheckForInvalidTypeCasts(node.elements);
			return node;
		}
		parseSubscript(base, startLoc, noCalls, state) {
			if (!this.hasPrecedingLineBreak() && this.match(35)) {
				this.state.canStartJSXElement = false;
				this.next();
				const nonNullExpression = this.startNodeAt(startLoc);
				nonNullExpression.expression = base;
				return this.finishNode(nonNullExpression, "TSNonNullExpression");
			}
			let isOptionalCall = false;
			if (this.match(18) && this.lookaheadCharCode() === 60) {
				if (noCalls) {
					state.stop = true;
					return base;
				}
				state.optionalChainMember = isOptionalCall = true;
				this.next();
			}
			if (this.match(47) || this.match(51)) {
				let missingParenErrorLoc;
				const result = this.tsTryParseAndCatch(() => {
					if (!noCalls && this.atPossibleAsyncArrow(base)) {
						const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
						if (asyncArrowFn) {
							state.stop = true;
							return asyncArrowFn;
						}
					}
					const typeArguments = this.tsParseTypeArgumentsInExpression();
					if (!typeArguments) return;
					if (isOptionalCall && !this.match(10)) {
						missingParenErrorLoc = this.state.curPosition();
						return;
					}
					if (tokenIsTemplate(this.state.type)) {
						const result = super.parseTaggedTemplateExpression(base, startLoc, state);
						result.typeParameters = typeArguments;
						return result;
					}
					if (!noCalls && this.eat(10)) {
						const node = this.startNodeAt(startLoc);
						node.callee = base;
						node.arguments = this.parseCallExpressionArguments();
						this.tsCheckForInvalidTypeCasts(node.arguments);
						node.typeParameters = typeArguments;
						if (state.optionalChainMember) node.optional = isOptionalCall;
						return this.finishCallExpression(node, state.optionalChainMember);
					}
					const tokenType = this.state.type;
					if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenType !== 93 && tokenType !== 120 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) return;
					const node = this.startNodeAt(startLoc);
					node.expression = base;
					node.typeParameters = typeArguments;
					return this.finishNode(node, "TSInstantiationExpression");
				});
				if (missingParenErrorLoc) this.unexpected(missingParenErrorLoc, 10);
				if (result) {
					if (result.type === "TSInstantiationExpression") {
						if (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40) this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, this.state.startLoc);
						if (!this.match(16) && !this.match(18)) result.expression = super.stopParseSubscript(base, state);
					}
					return result;
				}
			}
			return super.parseSubscript(base, startLoc, noCalls, state);
		}
		parseNewCallee(node) {
			var _callee$extra;
			super.parseNewCallee(node);
			const { callee } = node;
			if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
				node.typeParameters = callee.typeParameters;
				node.callee = callee.expression;
			}
		}
		parseExprOp(left, leftStartLoc, minPrec) {
			let isSatisfies;
			if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(120)))) {
				const node = this.startNodeAt(leftStartLoc);
				node.expression = left;
				node.typeAnnotation = this.tsInType(() => {
					this.next();
					if (this.match(75)) {
						if (isSatisfies) this.raise(Errors.UnexpectedKeyword, this.state.startLoc, { keyword: "const" });
						return this.tsParseTypeReference();
					}
					return this.tsParseType();
				});
				this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
				this.reScan_lt_gt();
				return this.parseExprOp(node, leftStartLoc, minPrec);
			}
			return super.parseExprOp(left, leftStartLoc, minPrec);
		}
		checkReservedWord(word, startLoc, checkKeywords, isBinding) {
			if (!this.state.isAmbientContext) super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
		}
		checkImportReflection(node) {
			super.checkImportReflection(node);
			if (node.module && node.importKind !== "value") this.raise(TSErrors.ImportReflectionHasImportType, node.specifiers[0].loc.start);
		}
		checkDuplicateExports() {}
		isPotentialImportPhase(isExport) {
			if (super.isPotentialImportPhase(isExport)) return true;
			if (this.isContextual(130)) {
				const ch = this.lookaheadCharCode();
				return isExport ? ch === 123 || ch === 42 : ch !== 61;
			}
			return !isExport && this.isContextual(87);
		}
		applyImportPhase(node, isExport, phase, loc) {
			super.applyImportPhase(node, isExport, phase, loc);
			if (isExport) node.exportKind = phase === "type" ? "type" : "value";
			else node.importKind = phase === "type" || phase === "typeof" ? phase : "value";
		}
		parseImport(node) {
			if (this.match(134)) {
				node.importKind = "value";
				return super.parseImport(node);
			}
			let importNode;
			if (tokenIsIdentifier(this.state.type) && this.lookaheadCharCode() === 61) {
				node.importKind = "value";
				return this.tsParseImportEqualsDeclaration(node);
			} else if (this.isContextual(130)) {
				const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, false);
				if (this.lookaheadCharCode() === 61) return this.tsParseImportEqualsDeclaration(node, maybeDefaultIdentifier);
				else importNode = super.parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier);
			} else importNode = super.parseImport(node);
			if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, importNode);
			return importNode;
		}
		parseExport(node, decorators) {
			if (this.match(83)) {
				const nodeImportEquals = node;
				this.next();
				let maybeDefaultIdentifier = null;
				if (this.isContextual(130) && this.isPotentialImportPhase(false)) maybeDefaultIdentifier = this.parseMaybeImportPhase(nodeImportEquals, false);
				else nodeImportEquals.importKind = "value";
				return this.tsParseImportEqualsDeclaration(nodeImportEquals, maybeDefaultIdentifier, true);
			} else if (this.eat(29)) {
				const assign = node;
				assign.expression = super.parseExpression();
				this.semicolon();
				this.sawUnambiguousESM = true;
				return this.finishNode(assign, "TSExportAssignment");
			} else if (this.eatContextual(93)) {
				const decl = node;
				this.expectContextual(128);
				decl.id = this.parseIdentifier();
				this.semicolon();
				return this.finishNode(decl, "TSNamespaceExportDeclaration");
			} else return super.parseExport(node, decorators);
		}
		isAbstractClass() {
			return this.isContextual(124) && this.isLookaheadContextual("class");
		}
		parseExportDefaultExpression() {
			if (this.isAbstractClass()) {
				const cls = this.startNode();
				this.next();
				cls.abstract = true;
				return this.parseClass(cls, true, true);
			}
			if (this.match(129)) {
				const result = this.tsParseInterfaceDeclaration(this.startNode());
				if (result) return result;
			}
			return super.parseExportDefaultExpression();
		}
		parseVarStatement(node, kind, allowMissingInitializer = false) {
			const { isAmbientContext } = this.state;
			const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
			if (!isAmbientContext) return declaration;
			if (!node.declare && (kind === "using" || kind === "await using")) {
				this.raiseOverwrite(TSErrors.UsingDeclarationInAmbientContext, node, kind);
				return declaration;
			}
			for (const { id, init } of declaration.declarations) {
				if (!init) continue;
				if (kind === "var" || kind === "let" || !!id.typeAnnotation) this.raise(TSErrors.InitializerNotAllowedInAmbientContext, init);
				else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) this.raise(TSErrors.ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference, init);
			}
			return declaration;
		}
		parseStatementContent(flags, decorators) {
			if (!this.state.containsEsc) switch (this.state.type) {
				case 75:
					if (this.isLookaheadContextual("enum")) {
						const node = this.startNode();
						this.expect(75);
						return this.tsParseEnumDeclaration(node, { const: true });
					}
					break;
				case 124:
				case 125:
					if (this.nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine()) {
						const token = this.state.type;
						const node = this.startNode();
						this.next();
						const declaration = token === 125 ? this.tsTryParseDeclare(node) : this.tsParseAbstractDeclaration(node, decorators);
						if (declaration) {
							if (token === 125) declaration.declare = true;
							return declaration;
						} else {
							node.expression = this.createIdentifier(this.startNodeAt(node.loc.start), token === 125 ? "declare" : "abstract");
							this.semicolon(false);
							return this.finishNode(node, "ExpressionStatement");
						}
					}
					break;
				case 126: return this.tsParseEnumDeclaration(this.startNode());
				case 112:
					if (this.lookaheadCharCode() === 123) {
						const node = this.startNode();
						return this.tsParseAmbientExternalModuleDeclaration(node);
					}
					break;
				case 129: {
					const result = this.tsParseInterfaceDeclaration(this.startNode());
					if (result) return result;
					break;
				}
				case 127:
					if (this.nextTokenIsIdentifierOrStringLiteralOnSameLine()) {
						const node = this.startNode();
						this.next();
						return this.tsParseDeclaration(node, 127, false, decorators);
					}
					break;
				case 128:
					if (this.nextTokenIsIdentifierOnSameLine()) {
						const node = this.startNode();
						this.next();
						return this.tsParseDeclaration(node, 128, false, decorators);
					}
					break;
				case 130: if (this.nextTokenIsIdentifierOnSameLine()) {
					const node = this.startNode();
					this.next();
					return this.tsParseTypeAliasDeclaration(node);
				}
			}
			return super.parseStatementContent(flags, decorators);
		}
		parseAccessModifier() {
			return this.tsParseModifier([
				"public",
				"protected",
				"private"
			]);
		}
		tsHasSomeModifiers(member, modifiers) {
			return modifiers.some((modifier) => {
				if (tsIsAccessModifier(modifier)) return member.accessibility === modifier;
				return !!member[modifier];
			});
		}
		tsIsStartOfStaticBlocks() {
			return this.isContextual(106) && this.lookaheadCharCode() === 123;
		}
		parseClassMember(classBody, member, state) {
			const modifiers = [
				"declare",
				"private",
				"public",
				"protected",
				"override",
				"abstract",
				"readonly",
				"static"
			];
			this.tsParseModifiers({
				allowedModifiers: modifiers,
				disallowedModifiers: ["in", "out"],
				stopOnStartOfClassStaticBlock: true,
				errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
			}, member);
			const callParseClassMemberWithIsStatic = () => {
				if (this.tsIsStartOfStaticBlocks()) {
					this.next();
					this.next();
					if (this.tsHasSomeModifiers(member, modifiers)) this.raise(TSErrors.StaticBlockCannotHaveModifier, this.state.curPosition());
					super.parseClassStaticBlock(classBody, member);
				} else this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
			};
			if (member.declare) this.tsInAmbientContext(callParseClassMemberWithIsStatic);
			else callParseClassMemberWithIsStatic();
		}
		parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
			const idx = this.tsTryParseIndexSignature(member);
			if (idx) {
				classBody.body.push(idx);
				if (member.abstract) this.raise(TSErrors.IndexSignatureHasAbstract, member);
				if (member.accessibility) this.raise(TSErrors.IndexSignatureHasAccessibility, member, { modifier: member.accessibility });
				if (member.declare) this.raise(TSErrors.IndexSignatureHasDeclare, member);
				if (member.override) this.raise(TSErrors.IndexSignatureHasOverride, member);
				return;
			}
			if (!this.state.inAbstractClass && member.abstract) this.raise(TSErrors.NonAbstractClassHasAbstractMethod, member);
			if (member.override) {
				if (!state.hadSuperClass) this.raise(TSErrors.OverrideNotInSubClass, member);
			}
			super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
		}
		parsePostMemberNameModifiers(methodOrProp) {
			if (this.eat(17)) methodOrProp.optional = true;
			if (methodOrProp.readonly && this.match(10)) this.raise(TSErrors.ClassMethodHasReadonly, methodOrProp);
			if (methodOrProp.declare && this.match(10)) this.raise(TSErrors.ClassMethodHasDeclare, methodOrProp);
		}
		shouldParseExportDeclaration() {
			if (this.tsIsDeclarationStart()) return true;
			return super.shouldParseExportDeclaration();
		}
		parseConditional(expr, startLoc, refExpressionErrors) {
			if (!this.match(17)) return expr;
			if (this.state.maybeInArrowParameters) {
				const nextCh = this.lookaheadCharCode();
				if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
					this.setOptionalParametersError(refExpressionErrors);
					return expr;
				}
			}
			return super.parseConditional(expr, startLoc, refExpressionErrors);
		}
		parseParenItem(node, startLoc) {
			const newNode = super.parseParenItem(node, startLoc);
			if (this.eat(17)) {
				newNode.optional = true;
				this.resetEndLocation(node);
			}
			if (this.match(14)) {
				const typeCastNode = this.startNodeAt(startLoc);
				typeCastNode.expression = node;
				typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
				return this.finishNode(typeCastNode, "TSTypeCastExpression");
			}
			return node;
		}
		parseExportDeclaration(node) {
			if (!this.state.isAmbientContext && this.isContextual(125)) return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
			const startLoc = this.state.startLoc;
			const isDeclare = this.eatContextual(125);
			if (isDeclare && (this.isContextual(125) || !this.shouldParseExportDeclaration())) throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, this.state.startLoc);
			const declaration = tokenIsIdentifier(this.state.type) && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
			if (!declaration) return null;
			if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) node.exportKind = "type";
			if (isDeclare && declaration.type !== "TSImportEqualsDeclaration") {
				this.resetStartLocation(declaration, startLoc);
				declaration.declare = true;
			}
			return declaration;
		}
		parseClassId(node, isStatement, optionalId, bindingType) {
			if ((!isStatement || optionalId) && this.isContextual(113)) return;
			super.parseClassId(node, isStatement, optionalId, node.declare ? 1024 : 8331);
			const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
			if (typeParameters) node.typeParameters = typeParameters;
		}
		parseClassPropertyAnnotation(node) {
			if (!node.optional) {
				if (this.eat(35)) node.definite = true;
				else if (this.eat(17)) node.optional = true;
			}
			const type = this.tsTryParseTypeAnnotation();
			if (type) node.typeAnnotation = type;
		}
		parseClassProperty(node) {
			this.parseClassPropertyAnnotation(node);
			if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) this.raise(TSErrors.DeclareClassFieldHasInitializer, this.state.startLoc);
			if (node.abstract && this.match(29)) {
				const { key } = node;
				this.raise(TSErrors.AbstractPropertyHasInitializer, this.state.startLoc, { propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` });
			}
			return super.parseClassProperty(node);
		}
		parseClassPrivateProperty(node) {
			if (node.abstract) this.raise(TSErrors.PrivateElementHasAbstract, node);
			if (node.accessibility) this.raise(TSErrors.PrivateElementHasAccessibility, node, { modifier: node.accessibility });
			this.parseClassPropertyAnnotation(node);
			return super.parseClassPrivateProperty(node);
		}
		parseClassAccessorProperty(node) {
			this.parseClassPropertyAnnotation(node);
			if (node.optional) this.raise(TSErrors.AccessorCannotBeOptional, node);
			return super.parseClassAccessorProperty(node);
		}
		pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
			const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
			if (typeParameters && isConstructor) this.raise(TSErrors.ConstructorHasTypeParameters, typeParameters);
			const { declare = false, kind } = method;
			if (declare && (kind === "get" || kind === "set")) this.raise(TSErrors.DeclareAccessor, method, { kind });
			if (typeParameters) method.typeParameters = typeParameters;
			super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
		}
		pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
			const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
			if (typeParameters) method.typeParameters = typeParameters;
			super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
		}
		declareClassPrivateMethodInScope(node, kind) {
			if (node.type === "TSDeclareMethod") return;
			if (node.type === "MethodDefinition" && node.value.body == null) return;
			super.declareClassPrivateMethodInScope(node, kind);
		}
		parseClassSuper(node) {
			super.parseClassSuper(node);
			if (node.superClass) {
				if (node.superClass.type === "TSInstantiationExpression") {
					const tsInstantiationExpression = node.superClass;
					const superClass = tsInstantiationExpression.expression;
					this.takeSurroundingComments(superClass, superClass.start, superClass.end);
					const superTypeArguments = tsInstantiationExpression.typeParameters;
					this.takeSurroundingComments(superTypeArguments, superTypeArguments.start, superTypeArguments.end);
					node.superClass = superClass;
					node.superTypeParameters = superTypeArguments;
				} else if (this.match(47) || this.match(51)) node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
			}
			if (this.eatContextual(113)) node.implements = this.tsParseHeritageClause("implements");
		}
		parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
			const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
			if (typeParameters) prop.typeParameters = typeParameters;
			return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
		}
		parseFunctionParams(node, isConstructor) {
			const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
			if (typeParameters) node.typeParameters = typeParameters;
			super.parseFunctionParams(node, isConstructor);
		}
		parseVarId(decl, kind) {
			super.parseVarId(decl, kind);
			if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) decl.definite = true;
			const type = this.tsTryParseTypeAnnotation();
			if (type) {
				decl.id.typeAnnotation = type;
				this.resetEndLocation(decl.id);
			}
		}
		parseAsyncArrowFromCallExpression(node, call) {
			if (this.match(14)) node.returnType = this.tsParseTypeAnnotation();
			return super.parseAsyncArrowFromCallExpression(node, call);
		}
		parseMaybeAssign(refExpressionErrors, afterLeftParse) {
			var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2;
			let state;
			let jsx;
			let typeCast;
			if (this.hasPlugin("jsx") && (this.match(143) || this.match(47))) {
				state = this.state.clone();
				jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
				if (!jsx.error) return jsx.node;
				const { context } = this.state;
				const currentContext = context[context.length - 1];
				if (currentContext === types.j_oTag || currentContext === types.j_expr) context.pop();
			}
			if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
			if (!state || state === this.state) state = this.state.clone();
			let typeParameters;
			const arrow = this.tryParse((abort) => {
				var _expr$extra, _typeParameters;
				typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
				const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
				if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) abort();
				if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) this.resetStartLocationFromNode(expr, typeParameters);
				expr.typeParameters = typeParameters;
				return expr;
			}, state);
			if (!arrow.error && !arrow.aborted) {
				if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
				return arrow.node;
			}
			if (!jsx) {
				assert(!this.hasPlugin("jsx"));
				typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
				if (!typeCast.error) return typeCast.node;
			}
			if ((_jsx2 = jsx) != null && _jsx2.node) {
				this.state = jsx.failState;
				return jsx.node;
			}
			if (arrow.node) {
				this.state = arrow.failState;
				if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
				return arrow.node;
			}
			if ((_typeCast = typeCast) != null && _typeCast.node) {
				this.state = typeCast.failState;
				return typeCast.node;
			}
			throw ((_jsx3 = jsx) == null ? void 0 : _jsx3.error) || arrow.error || ((_typeCast2 = typeCast) == null ? void 0 : _typeCast2.error);
		}
		reportReservedArrowTypeParam(node) {
			var _node$extra2;
			if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra2 = node.extra) != null && _node$extra2.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) this.raise(TSErrors.ReservedArrowTypeParam, node);
		}
		parseMaybeUnary(refExpressionErrors, sawUnary) {
			if (!this.hasPlugin("jsx") && this.match(47)) return this.tsParseTypeAssertion();
			return super.parseMaybeUnary(refExpressionErrors, sawUnary);
		}
		parseArrow(node) {
			if (this.match(14)) {
				const result = this.tryParse((abort) => {
					const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
					if (this.canInsertSemicolon() || !this.match(19)) abort();
					return returnType;
				});
				if (result.aborted) return;
				if (!result.thrown) {
					if (result.error) this.state = result.failState;
					node.returnType = result.node;
				}
			}
			return super.parseArrow(node);
		}
		parseFunctionParamType(param) {
			if (this.eat(17)) param.optional = true;
			const type = this.tsTryParseTypeAnnotation();
			if (type) param.typeAnnotation = type;
			this.resetEndLocation(param);
			return param;
		}
		isAssignable(node, isBinding) {
			switch (node.type) {
				case "TSTypeCastExpression": return this.isAssignable(node.expression, isBinding);
				case "TSParameterProperty": return true;
				default: return super.isAssignable(node, isBinding);
			}
		}
		toAssignable(node, isLHS = false) {
			switch (node.type) {
				case "ParenthesizedExpression":
					this.toAssignableParenthesizedExpression(node, isLHS);
					break;
				case "TSAsExpression":
				case "TSSatisfiesExpression":
				case "TSNonNullExpression":
				case "TSTypeAssertion":
					if (isLHS) this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, node);
					else this.raise(TSErrors.UnexpectedTypeCastInParameter, node);
					this.toAssignable(node.expression, isLHS);
					break;
				case "AssignmentExpression": if (!isLHS && node.left.type === "TSTypeCastExpression") node.left = this.typeCastToParameter(node.left);
				default: super.toAssignable(node, isLHS);
			}
		}
		toAssignableParenthesizedExpression(node, isLHS) {
			switch (node.expression.type) {
				case "TSAsExpression":
				case "TSSatisfiesExpression":
				case "TSNonNullExpression":
				case "TSTypeAssertion":
				case "ParenthesizedExpression":
					this.toAssignable(node.expression, isLHS);
					break;
				default: super.toAssignable(node, isLHS);
			}
		}
		checkToRestConversion(node, allowPattern) {
			switch (node.type) {
				case "TSAsExpression":
				case "TSSatisfiesExpression":
				case "TSTypeAssertion":
				case "TSNonNullExpression":
					this.checkToRestConversion(node.expression, false);
					break;
				default: super.checkToRestConversion(node, allowPattern);
			}
		}
		isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding) {
			switch (type) {
				case "TSTypeCastExpression": return true;
				case "TSParameterProperty": return "parameter";
				case "TSNonNullExpression": return "expression";
				case "TSAsExpression":
				case "TSSatisfiesExpression":
				case "TSTypeAssertion": return (binding !== 64 || !isUnparenthesizedInAssign) && ["expression", true];
				default: return super.isValidLVal(type, disallowCallExpression, isUnparenthesizedInAssign, binding);
			}
		}
		parseBindingAtom() {
			if (this.state.type === 78) return this.parseIdentifier(true);
			return super.parseBindingAtom();
		}
		parseMaybeDecoratorArguments(expr, startLoc) {
			if (this.match(47) || this.match(51)) {
				const typeArguments = this.tsParseTypeArgumentsInExpression();
				if (this.match(10)) {
					const call = super.parseMaybeDecoratorArguments(expr, startLoc);
					call.typeParameters = typeArguments;
					return call;
				}
				this.unexpected(null, 10);
			}
			return super.parseMaybeDecoratorArguments(expr, startLoc);
		}
		checkCommaAfterRest(close) {
			if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
				this.next();
				return false;
			}
			return super.checkCommaAfterRest(close);
		}
		isClassMethod() {
			return this.match(47) || super.isClassMethod();
		}
		isClassProperty() {
			return this.match(35) || this.match(14) || super.isClassProperty();
		}
		parseMaybeDefault(startLoc, left) {
			const node = super.parseMaybeDefault(startLoc, left);
			if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) this.raise(TSErrors.TypeAnnotationAfterAssign, node.typeAnnotation);
			return node;
		}
		getTokenFromCode(code) {
			if (this.state.inType) {
				if (code === 62) {
					this.finishOp(48, 1);
					return;
				}
				if (code === 60) {
					this.finishOp(47, 1);
					return;
				}
			}
			super.getTokenFromCode(code);
		}
		reScan_lt_gt() {
			const { type } = this.state;
			if (type === 47) {
				this.state.pos -= 1;
				this.readToken_lt();
			} else if (type === 48) {
				this.state.pos -= 1;
				this.readToken_gt();
			}
		}
		reScan_lt() {
			const { type } = this.state;
			if (type === 51) {
				this.state.pos -= 2;
				this.finishOp(47, 1);
				return 47;
			}
			return type;
		}
		toAssignableListItem(exprList, index, isLHS) {
			const node = exprList[index];
			if (node.type === "TSTypeCastExpression") exprList[index] = this.typeCastToParameter(node);
			super.toAssignableListItem(exprList, index, isLHS);
		}
		typeCastToParameter(node) {
			node.expression.typeAnnotation = node.typeAnnotation;
			this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
			return node.expression;
		}
		shouldParseArrow(params) {
			if (this.match(14)) return params.every((expr) => this.isAssignable(expr, true));
			return super.shouldParseArrow(params);
		}
		shouldParseAsyncArrow() {
			return this.match(14) || super.shouldParseAsyncArrow();
		}
		canHaveLeadingDecorator() {
			return super.canHaveLeadingDecorator() || this.isAbstractClass();
		}
		jsxParseOpeningElementAfterName(node) {
			if (this.match(47) || this.match(51)) {
				const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
				if (typeArguments) node.typeParameters = typeArguments;
			}
			return super.jsxParseOpeningElementAfterName(node);
		}
		getGetterSetterExpectedParamCount(method) {
			const baseCount = super.getGetterSetterExpectedParamCount(method);
			const firstParam = this.getObjectOrClassMethodParams(method)[0];
			return firstParam && this.isThisParam(firstParam) ? baseCount + 1 : baseCount;
		}
		parseCatchClauseParam() {
			const param = super.parseCatchClauseParam();
			const type = this.tsTryParseTypeAnnotation();
			if (type) {
				param.typeAnnotation = type;
				this.resetEndLocation(param);
			}
			return param;
		}
		tsInAmbientContext(cb) {
			const { isAmbientContext: oldIsAmbientContext, strict: oldStrict } = this.state;
			this.state.isAmbientContext = true;
			this.state.strict = false;
			try {
				return cb();
			} finally {
				this.state.isAmbientContext = oldIsAmbientContext;
				this.state.strict = oldStrict;
			}
		}
		parseClass(node, isStatement, optionalId) {
			const oldInAbstractClass = this.state.inAbstractClass;
			this.state.inAbstractClass = !!node.abstract;
			try {
				return super.parseClass(node, isStatement, optionalId);
			} finally {
				this.state.inAbstractClass = oldInAbstractClass;
			}
		}
		tsParseAbstractDeclaration(node, decorators) {
			if (this.match(80)) {
				node.abstract = true;
				return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
			} else if (this.isContextual(129)) {
				if (!this.hasFollowingLineBreak()) {
					node.abstract = true;
					this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifier, node);
					return this.tsParseInterfaceDeclaration(node);
				} else return null;
			}
			throw this.unexpected(null, 80);
		}
		parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
			const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
			if (method.abstract || method.type === "TSAbstractMethodDefinition") {
				if ((this.hasPlugin("estree") ? method.value : method).body) {
					const { key } = method;
					this.raise(TSErrors.AbstractMethodHasImplementation, method, { methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(this.offsetToSourcePos(key.start), this.offsetToSourcePos(key.end))}]` });
				}
			}
			return method;
		}
		tsParseTypeParameterName() {
			return this.parseIdentifier().name;
		}
		shouldParseAsAmbientContext() {
			return !!this.getPluginOption("typescript", "dts");
		}
		parse() {
			if (this.shouldParseAsAmbientContext()) this.state.isAmbientContext = true;
			return super.parse();
		}
		getExpression() {
			if (this.shouldParseAsAmbientContext()) this.state.isAmbientContext = true;
			return super.getExpression();
		}
		parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
			if (!isString && isMaybeTypeOnly) {
				this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
				return this.finishNode(node, "ExportSpecifier");
			}
			node.exportKind = "value";
			return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
		}
		parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
			if (!importedIsString && isMaybeTypeOnly) {
				this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
				return this.finishNode(specifier, "ImportSpecifier");
			}
			specifier.importKind = "value";
			return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? 4098 : 4096);
		}
		parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
			const leftOfAsKey = isImport ? "imported" : "local";
			const rightOfAsKey = isImport ? "local" : "exported";
			let leftOfAs = node[leftOfAsKey];
			let rightOfAs;
			let hasTypeSpecifier = false;
			let canParseAsKeyword = true;
			const loc = leftOfAs.loc.start;
			if (this.isContextual(93)) {
				const firstAs = this.parseIdentifier();
				if (this.isContextual(93)) {
					const secondAs = this.parseIdentifier();
					if (tokenIsKeywordOrIdentifier(this.state.type)) {
						hasTypeSpecifier = true;
						leftOfAs = firstAs;
						rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
						canParseAsKeyword = false;
					} else {
						rightOfAs = secondAs;
						canParseAsKeyword = false;
					}
				} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
					canParseAsKeyword = false;
					rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
				} else {
					hasTypeSpecifier = true;
					leftOfAs = firstAs;
				}
			} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
				hasTypeSpecifier = true;
				if (isImport) {
					leftOfAs = this.parseIdentifier(true);
					if (!this.isContextual(93)) this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
				} else leftOfAs = this.parseModuleExportName();
			}
			if (hasTypeSpecifier && isInTypeOnlyImportExport) this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, loc);
			node[leftOfAsKey] = leftOfAs;
			node[rightOfAsKey] = rightOfAs;
			const kindKey = isImport ? "importKind" : "exportKind";
			node[kindKey] = hasTypeSpecifier ? "type" : "value";
			if (canParseAsKeyword && this.eatContextual(93)) node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
			if (!node[rightOfAsKey]) node[rightOfAsKey] = this.cloneIdentifier(node[leftOfAsKey]);
			if (isImport) this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? 4098 : 4096);
		}
		fillOptionalPropertiesForTSESLint(node) {
			switch (node.type) {
				case "ExpressionStatement":
					node.directive != null || (node.directive = void 0);
					return;
				case "RestElement": node.value = void 0;
				case "Identifier":
				case "ArrayPattern":
				case "AssignmentPattern":
				case "ObjectPattern":
					node.decorators != null || (node.decorators = []);
					node.optional != null || (node.optional = false);
					node.typeAnnotation != null || (node.typeAnnotation = void 0);
					return;
				case "TSParameterProperty":
					node.accessibility != null || (node.accessibility = void 0);
					node.decorators != null || (node.decorators = []);
					node.override != null || (node.override = false);
					node.readonly != null || (node.readonly = false);
					node.static != null || (node.static = false);
					return;
				case "TSEmptyBodyFunctionExpression": node.body = null;
				case "TSDeclareFunction":
				case "FunctionDeclaration":
				case "FunctionExpression":
				case "ClassMethod":
				case "ClassPrivateMethod":
					node.declare != null || (node.declare = false);
					node.returnType != null || (node.returnType = void 0);
					node.typeParameters != null || (node.typeParameters = void 0);
					return;
				case "Property":
					node.optional != null || (node.optional = false);
					return;
				case "TSMethodSignature":
				case "TSPropertySignature": node.optional != null || (node.optional = false);
				case "TSIndexSignature":
					node.accessibility != null || (node.accessibility = void 0);
					node.readonly != null || (node.readonly = false);
					node.static != null || (node.static = false);
					return;
				case "TSAbstractPropertyDefinition":
				case "PropertyDefinition":
				case "TSAbstractAccessorProperty":
				case "AccessorProperty":
					node.declare != null || (node.declare = false);
					node.definite != null || (node.definite = false);
					node.readonly != null || (node.readonly = false);
					node.typeAnnotation != null || (node.typeAnnotation = void 0);
				case "TSAbstractMethodDefinition":
				case "MethodDefinition":
					node.accessibility != null || (node.accessibility = void 0);
					node.decorators != null || (node.decorators = []);
					node.override != null || (node.override = false);
					node.optional != null || (node.optional = false);
					return;
				case "ClassExpression": node.id != null || (node.id = null);
				case "ClassDeclaration":
					node.abstract != null || (node.abstract = false);
					node.declare != null || (node.declare = false);
					node.decorators != null || (node.decorators = []);
					node.implements != null || (node.implements = []);
					node.superTypeArguments != null || (node.superTypeArguments = void 0);
					node.typeParameters != null || (node.typeParameters = void 0);
					return;
				case "TSTypeAliasDeclaration":
				case "VariableDeclaration":
					node.declare != null || (node.declare = false);
					return;
				case "VariableDeclarator":
					node.definite != null || (node.definite = false);
					return;
				case "TSEnumDeclaration":
					node.const != null || (node.const = false);
					node.declare != null || (node.declare = false);
					return;
				case "TSEnumMember":
					node.computed != null || (node.computed = false);
					return;
				case "TSImportType":
					node.qualifier != null || (node.qualifier = null);
					node.options != null || (node.options = null);
					return;
				case "TSInterfaceDeclaration":
					node.declare != null || (node.declare = false);
					node.extends != null || (node.extends = []);
					return;
				case "TSMappedType":
					node.optional != null || (node.optional = false);
					node.readonly != null || (node.readonly = void 0);
					return;
				case "TSModuleDeclaration":
					node.declare != null || (node.declare = false);
					node.global != null || (node.global = node.kind === "global");
					return;
				case "TSTypeParameter":
					node.const != null || (node.const = false);
					node.in != null || (node.in = false);
					node.out != null || (node.out = false);
					return;
			}
		}
		chStartsBindingIdentifierAndNotRelationalOperator(ch, pos) {
			if (isIdentifierStart(ch)) {
				keywordAndTSRelationalOperator.lastIndex = pos;
				if (keywordAndTSRelationalOperator.test(this.input)) {
					const endCh = this.codePointAtPos(keywordAndTSRelationalOperator.lastIndex);
					if (!isIdentifierChar(endCh) && endCh !== 92) return false;
				}
				return true;
			} else if (ch === 92) return true;
			else return false;
		}
		nextTokenIsIdentifierAndNotTSRelationalOperatorOnSameLine() {
			const next = this.nextTokenInLineStart();
			const nextCh = this.codePointAtPos(next);
			return this.chStartsBindingIdentifierAndNotRelationalOperator(nextCh, next);
		}
		nextTokenIsIdentifierOrStringLiteralOnSameLine() {
			const next = this.nextTokenInLineStart();
			const nextCh = this.codePointAtPos(next);
			return this.chStartsBindingIdentifier(nextCh, next) || nextCh === 34 || nextCh === 39;
		}
	};
	function isPossiblyLiteralEnum(expression) {
		if (expression.type !== "MemberExpression") return false;
		const { computed, property } = expression;
		if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) return false;
		return isUncomputedMemberExpressionChain(expression.object);
	}
	function isValidAmbientConstInitializer(expression, estree) {
		var _expression$extra;
		const { type } = expression;
		if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) return false;
		if (estree) {
			if (type === "Literal") {
				const { value } = expression;
				if (typeof value === "string" || typeof value === "boolean") return true;
			}
		} else if (type === "StringLiteral" || type === "BooleanLiteral") return true;
		if (isNumber(expression, estree) || isNegativeNumber(expression, estree)) return true;
		if (type === "TemplateLiteral" && expression.expressions.length === 0) return true;
		if (isPossiblyLiteralEnum(expression)) return true;
		return false;
	}
	function isNumber(expression, estree) {
		if (estree) return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
		return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
	}
	function isNegativeNumber(expression, estree) {
		if (expression.type === "UnaryExpression") {
			const { operator, argument } = expression;
			if (operator === "-" && isNumber(argument, estree)) return true;
		}
		return false;
	}
	function isUncomputedMemberExpressionChain(expression) {
		if (expression.type === "Identifier") return true;
		if (expression.type !== "MemberExpression" || expression.computed) return false;
		return isUncomputedMemberExpressionChain(expression.object);
	}
	const PlaceholderErrors = ParseErrorEnum`placeholders`({
		ClassNameIsRequired: "A class name is required.",
		UnexpectedSpace: "Unexpected space in placeholder."
	});
	var placeholders = (superClass) => class PlaceholdersParserMixin extends superClass {
		parsePlaceholder(expectedNode) {
			if (this.match(133)) {
				const node = this.startNode();
				this.next();
				this.assertNoSpace();
				node.name = super.parseIdentifier(true);
				this.assertNoSpace();
				this.expect(133);
				return this.finishPlaceholder(node, expectedNode);
			}
		}
		finishPlaceholder(node, expectedNode) {
			let placeholder = node;
			if (!placeholder.expectedNode || !placeholder.type) placeholder = this.finishNode(placeholder, "Placeholder");
			placeholder.expectedNode = expectedNode;
			return placeholder;
		}
		getTokenFromCode(code) {
			if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) this.finishOp(133, 2);
			else super.getTokenFromCode(code);
		}
		parseExprAtom(refExpressionErrors) {
			return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
		}
		parseIdentifier(liberal) {
			return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
		}
		checkReservedWord(word, startLoc, checkKeywords, isBinding) {
			if (word !== void 0) super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
		}
		cloneIdentifier(node) {
			const cloned = super.cloneIdentifier(node);
			if (cloned.type === "Placeholder") cloned.expectedNode = node.expectedNode;
			return cloned;
		}
		cloneStringLiteral(node) {
			if (node.type === "Placeholder") return this.cloneIdentifier(node);
			return super.cloneStringLiteral(node);
		}
		parseBindingAtom() {
			return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
		}
		isValidLVal(type, disallowCallExpression, isParenthesized, binding) {
			return type === "Placeholder" || super.isValidLVal(type, disallowCallExpression, isParenthesized, binding);
		}
		toAssignable(node, isLHS) {
			if (node && node.type === "Placeholder" && node.expectedNode === "Expression") node.expectedNode = "Pattern";
			else super.toAssignable(node, isLHS);
		}
		chStartsBindingIdentifier(ch, pos) {
			if (super.chStartsBindingIdentifier(ch, pos)) return true;
			const next = this.nextTokenStart();
			if (this.input.charCodeAt(next) === 37 && this.input.charCodeAt(next + 1) === 37) return true;
			return false;
		}
		verifyBreakContinue(node, isBreak) {
			var _node$label;
			if (((_node$label = node.label) == null ? void 0 : _node$label.type) === "Placeholder") return;
			super.verifyBreakContinue(node, isBreak);
		}
		parseExpressionStatement(node, expr) {
			var _expr$extra;
			if (expr.type !== "Placeholder" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) return super.parseExpressionStatement(node, expr);
			if (this.match(14)) {
				const stmt = node;
				stmt.label = this.finishPlaceholder(expr, "Identifier");
				this.next();
				stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
				return this.finishNode(stmt, "LabeledStatement");
			}
			this.semicolon();
			const stmtPlaceholder = node;
			stmtPlaceholder.name = expr.name;
			return this.finishPlaceholder(stmtPlaceholder, "Statement");
		}
		parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
			return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
		}
		parseFunctionId(requireId) {
			return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
		}
		parseClass(node, isStatement, optionalId) {
			const type = isStatement ? "ClassDeclaration" : "ClassExpression";
			this.next();
			const oldStrict = this.state.strict;
			const placeholder = this.parsePlaceholder("Identifier");
			if (placeholder) {
				if (this.match(81) || this.match(133) || this.match(5)) node.id = placeholder;
				else if (optionalId || !isStatement) {
					node.id = null;
					node.body = this.finishPlaceholder(placeholder, "ClassBody");
					return this.finishNode(node, type);
				} else throw this.raise(PlaceholderErrors.ClassNameIsRequired, this.state.startLoc);
			} else this.parseClassId(node, isStatement, optionalId);
			super.parseClassSuper(node);
			node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
			return this.finishNode(node, type);
		}
		parseExport(node, decorators) {
			const placeholder = this.parsePlaceholder("Identifier");
			if (!placeholder) return super.parseExport(node, decorators);
			const node2 = node;
			if (!this.isContextual(98) && !this.match(12)) {
				node2.specifiers = [];
				node2.source = null;
				node2.declaration = this.finishPlaceholder(placeholder, "Declaration");
				return this.finishNode(node2, "ExportNamedDeclaration");
			}
			this.expectPlugin("exportDefaultFrom");
			const specifier = this.startNode();
			specifier.exported = placeholder;
			node2.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
			return super.parseExport(node2, decorators);
		}
		isExportDefaultSpecifier() {
			if (this.match(65)) {
				const next = this.nextTokenStart();
				if (this.isUnparsedContextual(next, "from")) {
					if (this.input.startsWith(tokenLabelName(133), this.nextTokenStartSince(next + 4))) return true;
				}
			}
			return super.isExportDefaultSpecifier();
		}
		maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
			var _specifiers;
			if ((_specifiers = node.specifiers) != null && _specifiers.length) return true;
			return super.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
		}
		checkExport(node) {
			const { specifiers } = node;
			if (specifiers != null && specifiers.length) node.specifiers = specifiers.filter((node) => node.exported.type === "Placeholder");
			super.checkExport(node);
			node.specifiers = specifiers;
		}
		parseImport(node) {
			const placeholder = this.parsePlaceholder("Identifier");
			if (!placeholder) return super.parseImport(node);
			node.specifiers = [];
			if (!this.isContextual(98) && !this.match(12)) {
				node.source = this.finishPlaceholder(placeholder, "StringLiteral");
				this.semicolon();
				return this.finishNode(node, "ImportDeclaration");
			}
			const specifier = this.startNodeAtNode(placeholder);
			specifier.local = placeholder;
			node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
			if (this.eat(12)) {
				if (!this.maybeParseStarImportSpecifier(node)) this.parseNamedImportSpecifiers(node);
			}
			this.expectContextual(98);
			node.source = this.parseImportSource();
			this.semicolon();
			return this.finishNode(node, "ImportDeclaration");
		}
		parseImportSource() {
			return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
		}
		assertNoSpace() {
			if (this.state.start > this.offsetToSourcePos(this.state.lastTokEndLoc.index)) this.raise(PlaceholderErrors.UnexpectedSpace, this.state.lastTokEndLoc);
		}
	};
	var v8intrinsic = (superClass) => class V8IntrinsicMixin extends superClass {
		parseV8Intrinsic() {
			if (this.match(54)) {
				const v8IntrinsicStartLoc = this.state.startLoc;
				const node = this.startNode();
				this.next();
				if (tokenIsIdentifier(this.state.type)) {
					const name = this.parseIdentifierName();
					const identifier = this.createIdentifier(node, name);
					this.castNodeTo(identifier, "V8IntrinsicIdentifier");
					if (this.match(10)) return identifier;
				}
				this.unexpected(v8IntrinsicStartLoc);
			}
		}
		parseExprAtom(refExpressionErrors) {
			return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
		}
	};
	const PIPELINE_PROPOSALS = [
		"minimal",
		"fsharp",
		"hack",
		"smart"
	];
	const TOPIC_TOKENS = [
		"^^",
		"@@",
		"^",
		"%",
		"#"
	];
	function validatePlugins(pluginsMap) {
		if (pluginsMap.has("decorators")) {
			if (pluginsMap.has("decorators-legacy")) throw new Error("Cannot use the decorators and decorators-legacy plugin together");
			const decoratorsBeforeExport = pluginsMap.get("decorators").decoratorsBeforeExport;
			if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
			const allowCallParenthesized = pluginsMap.get("decorators").allowCallParenthesized;
			if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") throw new Error("'allowCallParenthesized' must be a boolean.");
		}
		if (pluginsMap.has("flow") && pluginsMap.has("typescript")) throw new Error("Cannot combine flow and typescript plugins.");
		if (pluginsMap.has("placeholders") && pluginsMap.has("v8intrinsic")) throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
		if (pluginsMap.has("pipelineOperator")) {
			var _pluginsMap$get2;
			const proposal = pluginsMap.get("pipelineOperator").proposal;
			if (!PIPELINE_PROPOSALS.includes(proposal)) {
				const proposalList = PIPELINE_PROPOSALS.map((p) => `"${p}"`).join(", ");
				throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
			}
			if (proposal === "hack") {
				var _pluginsMap$get;
				if (pluginsMap.has("placeholders")) throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
				if (pluginsMap.has("v8intrinsic")) throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
				const topicToken = pluginsMap.get("pipelineOperator").topicToken;
				if (!TOPIC_TOKENS.includes(topicToken)) {
					const tokenList = TOPIC_TOKENS.map((t) => `"${t}"`).join(", ");
					throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
				}
				if (topicToken === "#" && ((_pluginsMap$get = pluginsMap.get("recordAndTuple")) == null ? void 0 : _pluginsMap$get.syntaxType) === "hash") throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "hack", topicToken: "#" }]\` and \`${JSON.stringify(["recordAndTuple", pluginsMap.get("recordAndTuple")])}\`.`);
			} else if (proposal === "smart" && ((_pluginsMap$get2 = pluginsMap.get("recordAndTuple")) == null ? void 0 : _pluginsMap$get2.syntaxType) === "hash") throw new Error(`Plugin conflict between \`["pipelineOperator", { proposal: "smart" }]\` and \`${JSON.stringify(["recordAndTuple", pluginsMap.get("recordAndTuple")])}\`.`);
		}
		if (pluginsMap.has("moduleAttributes")) {
			if (pluginsMap.has("deprecatedImportAssert") || pluginsMap.has("importAssertions")) throw new Error("Cannot combine importAssertions, deprecatedImportAssert and moduleAttributes plugins.");
			if (pluginsMap.get("moduleAttributes").version !== "may-2020") throw new Error("The 'moduleAttributes' plugin requires a 'version' option, representing the last proposal update. Currently, the only supported value is 'may-2020'.");
		}
		if (pluginsMap.has("importAssertions")) {
			if (pluginsMap.has("deprecatedImportAssert")) throw new Error("Cannot combine importAssertions and deprecatedImportAssert plugins.");
		}
		if (pluginsMap.has("deprecatedImportAssert"));
		else if (pluginsMap.has("importAttributes") && pluginsMap.get("importAttributes").deprecatedAssertSyntax) pluginsMap.set("deprecatedImportAssert", {});
		if (pluginsMap.has("recordAndTuple")) {
			const syntaxType = pluginsMap.get("recordAndTuple").syntaxType;
			if (syntaxType != null) {
				const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
				if (!RECORD_AND_TUPLE_SYNTAX_TYPES.includes(syntaxType)) throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p) => `'${p}'`).join(", "));
			}
		}
		if (pluginsMap.has("asyncDoExpressions") && !pluginsMap.has("doExpressions")) {
			const error = /* @__PURE__ */ new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
			error.missingPlugins = "doExpressions";
			throw error;
		}
		if (pluginsMap.has("optionalChainingAssign") && pluginsMap.get("optionalChainingAssign").version !== "2023-07") throw new Error("The 'optionalChainingAssign' plugin requires a 'version' option, representing the last proposal update. Currently, the only supported value is '2023-07'.");
		if (pluginsMap.has("discardBinding") && pluginsMap.get("discardBinding").syntaxType !== "void") throw new Error("The 'discardBinding' plugin requires a 'syntaxType' option. Currently the only supported value is 'void'.");
	}
	const mixinPlugins = {
		estree,
		jsx,
		flow,
		typescript,
		v8intrinsic,
		placeholders
	};
	const mixinPluginNames = Object.keys(mixinPlugins);
	var ExpressionParser = class extends LValParser {
		checkProto(prop, isRecord, sawProto, refExpressionErrors) {
			if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) return sawProto;
			const key = prop.key;
			if ((key.type === "Identifier" ? key.name : key.value) === "__proto__") {
				if (isRecord) {
					this.raise(Errors.RecordNoProto, key);
					return true;
				}
				if (sawProto) {
					if (refExpressionErrors) {
						if (refExpressionErrors.doubleProtoLoc === null) refExpressionErrors.doubleProtoLoc = key.loc.start;
					} else this.raise(Errors.DuplicateProto, key);
				}
				return true;
			}
			return sawProto;
		}
		shouldExitDescending(expr, potentialArrowAt) {
			return expr.type === "ArrowFunctionExpression" && this.offsetToSourcePos(expr.start) === potentialArrowAt;
		}
		getExpression() {
			this.enterInitialScopes();
			this.nextToken();
			if (this.match(140)) throw this.raise(Errors.ParseExpressionEmptyInput, this.state.startLoc);
			const expr = this.parseExpression();
			if (!this.match(140)) throw this.raise(Errors.ParseExpressionExpectsEOF, this.state.startLoc, { unexpected: this.input.codePointAt(this.state.start) });
			this.finalizeRemainingComments();
			expr.comments = this.comments;
			expr.errors = this.state.errors;
			if (this.optionFlags & 256) expr.tokens = this.tokens;
			return expr;
		}
		parseExpression(disallowIn, refExpressionErrors) {
			if (disallowIn) return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));
			return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));
		}
		parseExpressionBase(refExpressionErrors) {
			const startLoc = this.state.startLoc;
			const expr = this.parseMaybeAssign(refExpressionErrors);
			if (this.match(12)) {
				const node = this.startNodeAt(startLoc);
				node.expressions = [expr];
				while (this.eat(12)) node.expressions.push(this.parseMaybeAssign(refExpressionErrors));
				this.toReferencedList(node.expressions);
				return this.finishNode(node, "SequenceExpression");
			}
			return expr;
		}
		parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {
			return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
		}
		parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
			return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
		}
		setOptionalParametersError(refExpressionErrors) {
			refExpressionErrors.optionalParametersLoc = this.state.startLoc;
		}
		parseMaybeAssign(refExpressionErrors, afterLeftParse) {
			const startLoc = this.state.startLoc;
			const isYield = this.isContextual(108);
			if (isYield) {
				if (this.prodParam.hasYield) {
					this.next();
					let left = this.parseYield(startLoc);
					if (afterLeftParse) left = afterLeftParse.call(this, left, startLoc);
					return left;
				}
			}
			let ownExpressionErrors;
			if (refExpressionErrors) ownExpressionErrors = false;
			else {
				refExpressionErrors = new ExpressionErrors();
				ownExpressionErrors = true;
			}
			const { type } = this.state;
			if (type === 10 || tokenIsIdentifier(type)) this.state.potentialArrowAt = this.state.start;
			let left = this.parseMaybeConditional(refExpressionErrors);
			if (afterLeftParse) left = afterLeftParse.call(this, left, startLoc);
			if (tokenIsAssignment(this.state.type)) {
				const node = this.startNodeAt(startLoc);
				const operator = this.state.value;
				node.operator = operator;
				if (this.match(29)) {
					this.toAssignable(left, true);
					node.left = left;
					const startIndex = startLoc.index;
					if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) refExpressionErrors.doubleProtoLoc = null;
					if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) refExpressionErrors.shorthandAssignLoc = null;
					if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {
						this.checkDestructuringPrivate(refExpressionErrors);
						refExpressionErrors.privateKeyLoc = null;
					}
					if (refExpressionErrors.voidPatternLoc != null && refExpressionErrors.voidPatternLoc.index >= startIndex) refExpressionErrors.voidPatternLoc = null;
				} else node.left = left;
				this.next();
				node.right = this.parseMaybeAssign();
				this.checkLVal(left, this.finishNode(node, "AssignmentExpression"), void 0, void 0, void 0, void 0, operator === "||=" || operator === "&&=" || operator === "??=");
				return node;
			} else if (ownExpressionErrors) this.checkExpressionErrors(refExpressionErrors, true);
			if (isYield) {
				const { type } = this.state;
				if ((this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54)) && !this.isAmbiguousPrefixOrIdentifier()) {
					this.raiseOverwrite(Errors.YieldNotInGeneratorFunction, startLoc);
					return this.parseYield(startLoc);
				}
			}
			return left;
		}
		parseMaybeConditional(refExpressionErrors) {
			const startLoc = this.state.startLoc;
			const potentialArrowAt = this.state.potentialArrowAt;
			const expr = this.parseExprOps(refExpressionErrors);
			if (this.shouldExitDescending(expr, potentialArrowAt)) return expr;
			return this.parseConditional(expr, startLoc, refExpressionErrors);
		}
		parseConditional(expr, startLoc, refExpressionErrors) {
			if (this.eat(17)) {
				const node = this.startNodeAt(startLoc);
				node.test = expr;
				node.consequent = this.parseMaybeAssignAllowIn();
				this.expect(14);
				node.alternate = this.parseMaybeAssign();
				return this.finishNode(node, "ConditionalExpression");
			}
			return expr;
		}
		parseMaybeUnaryOrPrivate(refExpressionErrors) {
			return this.match(139) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
		}
		parseExprOps(refExpressionErrors) {
			const startLoc = this.state.startLoc;
			const potentialArrowAt = this.state.potentialArrowAt;
			const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);
			if (this.shouldExitDescending(expr, potentialArrowAt)) return expr;
			return this.parseExprOp(expr, startLoc, -1);
		}
		parseExprOp(left, leftStartLoc, minPrec) {
			if (this.isPrivateName(left)) {
				const value = this.getPrivateNameSV(left);
				if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) this.raise(Errors.PrivateInExpectedIn, left, { identifierName: value });
				this.classScope.usePrivateName(value, left.loc.start);
			}
			const op = this.state.type;
			if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {
				let prec = tokenOperatorPrecedence(op);
				if (prec > minPrec) {
					if (op === 39) {
						this.expectPlugin("pipelineOperator");
						if (this.state.inFSharpPipelineDirectBody) return left;
						this.checkPipelineAtInfixOperator(left, leftStartLoc);
					}
					const node = this.startNodeAt(leftStartLoc);
					node.left = left;
					node.operator = this.state.value;
					const logical = op === 41 || op === 42;
					const coalesce = op === 40;
					if (coalesce) prec = tokenOperatorPrecedence(42);
					this.next();
					if (op === 39 && this.hasPlugin(["pipelineOperator", { proposal: "minimal" }])) {
						if (this.state.type === 96 && this.prodParam.hasAwait) throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, this.state.startLoc);
					}
					node.right = this.parseExprOpRightExpr(op, prec);
					const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
					const nextOp = this.state.type;
					if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) throw this.raise(Errors.MixingCoalesceWithLogical, this.state.startLoc);
					return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
				}
			}
			return left;
		}
		parseExprOpRightExpr(op, prec) {
			const startLoc = this.state.startLoc;
			switch (op) {
				case 39:
					switch (this.getPluginOption("pipelineOperator", "proposal")) {
						case "hack": return this.withTopicBindingContext(() => {
							return this.parseHackPipeBody();
						});
						case "fsharp": return this.withSoloAwaitPermittingContext(() => {
							return this.parseFSharpPipelineBody(prec);
						});
					}
					if (this.getPluginOption("pipelineOperator", "proposal") === "smart") return this.withTopicBindingContext(() => {
						if (this.prodParam.hasYield && this.isContextual(108)) throw this.raise(Errors.PipeBodyIsTighter, this.state.startLoc);
						return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
					});
				default: return this.parseExprOpBaseRightExpr(op, prec);
			}
		}
		parseExprOpBaseRightExpr(op, prec) {
			const startLoc = this.state.startLoc;
			return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);
		}
		parseHackPipeBody() {
			var _body$extra;
			const { startLoc } = this.state;
			const body = this.parseMaybeAssign();
			if (UnparenthesizedPipeBodyDescriptions.has(body.type) && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) this.raise(Errors.PipeUnparenthesizedBody, startLoc, { type: body.type });
			if (!this.topicReferenceWasUsedInCurrentContext()) this.raise(Errors.PipeTopicUnused, startLoc);
			return body;
		}
		checkExponentialAfterUnary(node) {
			if (this.match(57)) this.raise(Errors.UnexpectedTokenUnaryExponentiation, node.argument);
		}
		parseMaybeUnary(refExpressionErrors, sawUnary) {
			const startLoc = this.state.startLoc;
			const isAwait = this.isContextual(96);
			if (isAwait && this.recordAwaitIfAllowed()) {
				this.next();
				const expr = this.parseAwait(startLoc);
				if (!sawUnary) this.checkExponentialAfterUnary(expr);
				return expr;
			}
			const update = this.match(34);
			const node = this.startNode();
			if (tokenIsPrefix(this.state.type)) {
				node.operator = this.state.value;
				node.prefix = true;
				if (this.match(72)) this.expectPlugin("throwExpressions");
				const isDelete = this.match(89);
				this.next();
				node.argument = this.parseMaybeUnary(null, true);
				this.checkExpressionErrors(refExpressionErrors, true);
				if (this.state.strict && isDelete) {
					const arg = node.argument;
					if (arg.type === "Identifier") this.raise(Errors.StrictDelete, node);
					else if (this.hasPropertyAsPrivateName(arg)) this.raise(Errors.DeletePrivateField, node);
				}
				if (!update) {
					if (!sawUnary) this.checkExponentialAfterUnary(node);
					return this.finishNode(node, "UnaryExpression");
				}
			}
			const expr = this.parseUpdate(node, update, refExpressionErrors);
			if (isAwait) {
				const { type } = this.state;
				if ((this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54)) && !this.isAmbiguousPrefixOrIdentifier()) {
					this.raiseOverwrite(Errors.AwaitNotInAsyncContext, startLoc);
					return this.parseAwait(startLoc);
				}
			}
			return expr;
		}
		parseUpdate(node, update, refExpressionErrors) {
			if (update) {
				const updateExpressionNode = node;
				this.checkLVal(updateExpressionNode.argument, this.finishNode(updateExpressionNode, "UpdateExpression"));
				return node;
			}
			const startLoc = this.state.startLoc;
			let expr = this.parseExprSubscripts(refExpressionErrors);
			if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
			while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
				const node = this.startNodeAt(startLoc);
				node.operator = this.state.value;
				node.prefix = false;
				node.argument = expr;
				this.next();
				this.checkLVal(expr, expr = this.finishNode(node, "UpdateExpression"));
			}
			return expr;
		}
		parseExprSubscripts(refExpressionErrors) {
			const startLoc = this.state.startLoc;
			const potentialArrowAt = this.state.potentialArrowAt;
			const expr = this.parseExprAtom(refExpressionErrors);
			if (this.shouldExitDescending(expr, potentialArrowAt)) return expr;
			return this.parseSubscripts(expr, startLoc);
		}
		parseSubscripts(base, startLoc, noCalls) {
			const state = {
				optionalChainMember: false,
				maybeAsyncArrow: this.atPossibleAsyncArrow(base),
				stop: false
			};
			do {
				base = this.parseSubscript(base, startLoc, noCalls, state);
				state.maybeAsyncArrow = false;
			} while (!state.stop);
			return base;
		}
		parseSubscript(base, startLoc, noCalls, state) {
			const { type } = this.state;
			if (!noCalls && type === 15) return this.parseBind(base, startLoc, state);
			else if (tokenIsTemplate(type)) return this.parseTaggedTemplateExpression(base, startLoc, state);
			let optional = false;
			if (type === 18) {
				if (noCalls) {
					this.raise(Errors.OptionalChainingNoNew, this.state.startLoc);
					if (this.lookaheadCharCode() === 40) return this.stopParseSubscript(base, state);
				}
				state.optionalChainMember = optional = true;
				this.next();
			}
			if (!noCalls && this.match(10)) return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);
			else {
				const computed = this.eat(0);
				if (computed || optional || this.eat(16)) return this.parseMember(base, startLoc, state, computed, optional);
				else return this.stopParseSubscript(base, state);
			}
		}
		stopParseSubscript(base, state) {
			state.stop = true;
			return base;
		}
		parseMember(base, startLoc, state, computed, optional) {
			const node = this.startNodeAt(startLoc);
			node.object = base;
			node.computed = computed;
			if (computed) {
				node.property = this.parseExpression();
				this.expect(3);
			} else if (this.match(139)) {
				if (base.type === "Super") this.raise(Errors.SuperPrivateField, startLoc);
				this.classScope.usePrivateName(this.state.value, this.state.startLoc);
				node.property = this.parsePrivateName();
			} else node.property = this.parseIdentifier(true);
			if (state.optionalChainMember) {
				node.optional = optional;
				return this.finishNode(node, "OptionalMemberExpression");
			} else return this.finishNode(node, "MemberExpression");
		}
		parseBind(base, startLoc, state) {
			const node = this.startNodeAt(startLoc);
			node.object = base;
			this.next();
			const isImport = this.match(83);
			const callee = this.parseNoCallExpr();
			if (callee.type === "Super" || isImport && callee.type === "ImportExpression" || callee.type === "Import") throw this.raise(Errors.UnsupportedBindRHS, callee);
			node.callee = callee;
			state.stop = true;
			return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, false);
		}
		parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {
			const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
			let refExpressionErrors = null;
			this.state.maybeInArrowParameters = true;
			this.next();
			const node = this.startNodeAt(startLoc);
			node.callee = base;
			const { maybeAsyncArrow, optionalChainMember } = state;
			if (maybeAsyncArrow) {
				this.expressionScope.enter(newAsyncArrowScope());
				refExpressionErrors = new ExpressionErrors();
			}
			if (optionalChainMember) node.optional = optional;
			if (optional) node.arguments = this.parseCallExpressionArguments();
			else node.arguments = this.parseCallExpressionArguments(base.type !== "Super", node, refExpressionErrors);
			let finishedNode = this.finishCallExpression(node, optionalChainMember);
			if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
				state.stop = true;
				this.checkDestructuringPrivate(refExpressionErrors);
				this.expressionScope.validateAsPattern();
				this.expressionScope.exit();
				finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);
			} else {
				if (maybeAsyncArrow) {
					this.checkExpressionErrors(refExpressionErrors, true);
					this.expressionScope.exit();
				}
				this.toReferencedArguments(finishedNode);
			}
			this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
			return finishedNode;
		}
		toReferencedArguments(node, isParenthesizedExpr) {
			this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
		}
		parseTaggedTemplateExpression(base, startLoc, state) {
			const node = this.startNodeAt(startLoc);
			node.tag = base;
			node.quasi = this.parseTemplate(true);
			if (state.optionalChainMember) this.raise(Errors.OptionalChainingNoTemplate, startLoc);
			return this.finishNode(node, "TaggedTemplateExpression");
		}
		atPossibleAsyncArrow(base) {
			return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && this.offsetToSourcePos(base.start) === this.state.potentialArrowAt;
		}
		finishCallExpression(node, optional) {
			if (node.callee.type === "Import") {
				if (node.arguments.length === 0 || node.arguments.length > 2) this.raise(Errors.ImportCallArity, node);
				else for (const arg of node.arguments) if (arg.type === "SpreadElement") this.raise(Errors.ImportCallSpreadArgument, arg);
			}
			return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
		}
		parseCallExpressionArguments(allowPlaceholder, nodeForExtra, refExpressionErrors) {
			const elts = [];
			let first = true;
			const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
			this.state.inFSharpPipelineDirectBody = false;
			while (!this.eat(11)) {
				if (first) first = false;
				else {
					this.expect(12);
					if (this.match(11)) {
						if (nodeForExtra) this.addTrailingCommaExtraToNode(nodeForExtra);
						this.next();
						break;
					}
				}
				elts.push(this.parseExprListItem(11, false, refExpressionErrors, allowPlaceholder));
			}
			this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
			return elts;
		}
		shouldParseAsyncArrow() {
			return this.match(19) && !this.canInsertSemicolon();
		}
		parseAsyncArrowFromCallExpression(node, call) {
			var _call$extra;
			this.resetPreviousNodeTrailingComments(call);
			this.expect(19);
			this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);
			if (call.innerComments) setInnerComments(node, call.innerComments);
			if (call.callee.trailingComments) setInnerComments(node, call.callee.trailingComments);
			return node;
		}
		parseNoCallExpr() {
			const startLoc = this.state.startLoc;
			return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
		}
		parseExprAtom(refExpressionErrors) {
			let node;
			let decorators = null;
			const { type } = this.state;
			switch (type) {
				case 79: return this.parseSuper();
				case 83:
					node = this.startNode();
					this.next();
					if (this.match(16)) return this.parseImportMetaPropertyOrPhaseCall(node);
					if (this.match(10)) {
						if (this.optionFlags & 512) return this.parseImportCall(node);
						else return this.finishNode(node, "Import");
					} else {
						this.raise(Errors.UnsupportedImport, this.state.lastTokStartLoc);
						return this.finishNode(node, "Import");
					}
				case 78:
					node = this.startNode();
					this.next();
					return this.finishNode(node, "ThisExpression");
				case 90: return this.parseDo(this.startNode(), false);
				case 56:
				case 31:
					this.readRegexp();
					return this.parseRegExpLiteral(this.state.value);
				case 135: return this.parseNumericLiteral(this.state.value);
				case 136: return this.parseBigIntLiteral(this.state.value);
				case 134: return this.parseStringLiteral(this.state.value);
				case 84: return this.parseNullLiteral();
				case 85: return this.parseBooleanLiteral(true);
				case 86: return this.parseBooleanLiteral(false);
				case 10: {
					const canBeArrow = this.state.potentialArrowAt === this.state.start;
					return this.parseParenAndDistinguishExpression(canBeArrow);
				}
				case 0: return this.parseArrayLike(3, false, refExpressionErrors);
				case 5: return this.parseObjectLike(8, false, false, refExpressionErrors);
				case 68: return this.parseFunctionOrFunctionSent();
				case 26: decorators = this.parseDecorators();
				case 80: return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);
				case 77: return this.parseNewOrNewTarget();
				case 25:
				case 24: return this.parseTemplate(false);
				case 15: {
					node = this.startNode();
					this.next();
					node.object = null;
					const callee = node.callee = this.parseNoCallExpr();
					if (callee.type === "MemberExpression") return this.finishNode(node, "BindExpression");
					else throw this.raise(Errors.UnsupportedBind, callee);
				}
				case 139:
					this.raise(Errors.PrivateInExpectedIn, this.state.startLoc, { identifierName: this.state.value });
					return this.parsePrivateName();
				case 33: return this.parseTopicReferenceThenEqualsSign(54, "%");
				case 32: return this.parseTopicReferenceThenEqualsSign(44, "^");
				case 37:
				case 38: return this.parseTopicReference("hack");
				case 44:
				case 54:
				case 27: {
					const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
					if (pipeProposal) return this.parseTopicReference(pipeProposal);
					throw this.unexpected();
				}
				case 47: {
					const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
					if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) throw this.expectOnePlugin([
						"jsx",
						"flow",
						"typescript"
					]);
					throw this.unexpected();
				}
				default:
					if (type === 137) return this.parseDecimalLiteral(this.state.value);
					else if (type === 2 || type === 1) return this.parseArrayLike(this.state.type === 2 ? 4 : 3, true);
					else if (type === 6 || type === 7) return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);
					if (tokenIsIdentifier(type)) {
						if (this.isContextual(127) && this.lookaheadInLineCharCode() === 123) return this.parseModuleExpression();
						const canBeArrow = this.state.potentialArrowAt === this.state.start;
						const containsEsc = this.state.containsEsc;
						const id = this.parseIdentifier();
						if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
							const { type } = this.state;
							if (type === 68) {
								this.resetPreviousNodeTrailingComments(id);
								this.next();
								return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
							} else if (tokenIsIdentifier(type)) {
								if (canBeArrow && this.lookaheadCharCode() === 61) return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
								else return id;
							} else if (type === 90) {
								this.resetPreviousNodeTrailingComments(id);
								return this.parseDo(this.startNodeAtNode(id), true);
							}
						}
						if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {
							this.next();
							return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
						}
						return id;
					} else throw this.unexpected();
			}
		}
		parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {
			const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
			if (pipeProposal) {
				this.state.type = topicTokenType;
				this.state.value = topicTokenValue;
				this.state.pos--;
				this.state.end--;
				this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);
				return this.parseTopicReference(pipeProposal);
			}
			throw this.unexpected();
		}
		parseTopicReference(pipeProposal) {
			const node = this.startNode();
			const startLoc = this.state.startLoc;
			const tokenType = this.state.type;
			this.next();
			return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);
		}
		finishTopicReference(node, startLoc, pipeProposal, tokenType) {
			if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
				if (pipeProposal === "hack") {
					if (!this.topicReferenceIsAllowedInCurrentContext()) this.raise(Errors.PipeTopicUnbound, startLoc);
					this.registerTopicReference();
					return this.finishNode(node, "TopicReference");
				} else {
					if (!this.topicReferenceIsAllowedInCurrentContext()) this.raise(Errors.PrimaryTopicNotAllowed, startLoc);
					this.registerTopicReference();
					return this.finishNode(node, "PipelinePrimaryTopicReference");
				}
			} else throw this.raise(Errors.PipeTopicUnconfiguredToken, startLoc, { token: tokenLabelName(tokenType) });
		}
		testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
			switch (pipeProposal) {
				case "hack": return this.hasPlugin(["pipelineOperator", { topicToken: tokenLabelName(tokenType) }]);
				case "smart": return tokenType === 27;
				default: throw this.raise(Errors.PipeTopicRequiresHackPipes, startLoc);
			}
		}
		parseAsyncArrowUnaryFunction(node) {
			this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));
			const params = [this.parseIdentifier()];
			this.prodParam.exit();
			if (this.hasPrecedingLineBreak()) this.raise(Errors.LineTerminatorBeforeArrow, this.state.curPosition());
			this.expect(19);
			return this.parseArrowExpression(node, params, true);
		}
		parseDo(node, isAsync) {
			this.expectPlugin("doExpressions");
			if (isAsync) this.expectPlugin("asyncDoExpressions");
			node.async = isAsync;
			this.next();
			const oldLabels = this.state.labels;
			this.state.labels = [];
			if (isAsync) {
				this.prodParam.enter(2);
				node.body = this.parseBlock();
				this.prodParam.exit();
			} else node.body = this.parseBlock();
			this.state.labels = oldLabels;
			return this.finishNode(node, "DoExpression");
		}
		parseSuper() {
			const node = this.startNode();
			this.next();
			if (this.match(10) && !this.scope.allowDirectSuper) {
				if (!(this.optionFlags & 16)) this.raise(Errors.SuperNotAllowed, node);
			} else if (!this.scope.allowSuper) {
				if (!(this.optionFlags & 16)) this.raise(Errors.UnexpectedSuper, node);
			}
			if (!this.match(10) && !this.match(0) && !this.match(16)) this.raise(Errors.UnsupportedSuper, node);
			return this.finishNode(node, "Super");
		}
		parsePrivateName() {
			const node = this.startNode();
			const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1));
			const name = this.state.value;
			this.next();
			node.id = this.createIdentifier(id, name);
			return this.finishNode(node, "PrivateName");
		}
		parseFunctionOrFunctionSent() {
			const node = this.startNode();
			this.next();
			if (this.prodParam.hasYield && this.match(16)) {
				const meta = this.createIdentifier(this.startNodeAtNode(node), "function");
				this.next();
				if (this.match(103)) this.expectPlugin("functionSent");
				else if (!this.hasPlugin("functionSent")) this.unexpected();
				return this.parseMetaProperty(node, meta, "sent");
			}
			return this.parseFunction(node);
		}
		parseMetaProperty(node, meta, propertyName) {
			node.meta = meta;
			const containsEsc = this.state.containsEsc;
			node.property = this.parseIdentifier(true);
			if (node.property.name !== propertyName || containsEsc) this.raise(Errors.UnsupportedMetaProperty, node.property, {
				target: meta.name,
				onlyValidPropertyName: propertyName
			});
			return this.finishNode(node, "MetaProperty");
		}
		parseImportMetaPropertyOrPhaseCall(node) {
			this.next();
			if (this.isContextual(105) || this.isContextual(97)) {
				const isSource = this.isContextual(105);
				this.expectPlugin(isSource ? "sourcePhaseImports" : "deferredImportEvaluation");
				this.next();
				node.phase = isSource ? "source" : "defer";
				return this.parseImportCall(node);
			} else {
				const id = this.createIdentifierAt(this.startNodeAtNode(node), "import", this.state.lastTokStartLoc);
				if (this.isContextual(101)) {
					if (!this.inModule) this.raise(Errors.ImportMetaOutsideModule, id);
					this.sawUnambiguousESM = true;
				}
				return this.parseMetaProperty(node, id, "meta");
			}
		}
		parseLiteralAtNode(value, type, node) {
			this.addExtra(node, "rawValue", value);
			this.addExtra(node, "raw", this.input.slice(this.offsetToSourcePos(node.start), this.state.end));
			node.value = value;
			this.next();
			return this.finishNode(node, type);
		}
		parseLiteral(value, type) {
			const node = this.startNode();
			return this.parseLiteralAtNode(value, type, node);
		}
		parseStringLiteral(value) {
			return this.parseLiteral(value, "StringLiteral");
		}
		parseNumericLiteral(value) {
			return this.parseLiteral(value, "NumericLiteral");
		}
		parseBigIntLiteral(value) {
			return this.parseLiteral(value, "BigIntLiteral");
		}
		parseDecimalLiteral(value) {
			return this.parseLiteral(value, "DecimalLiteral");
		}
		parseRegExpLiteral(value) {
			const node = this.startNode();
			this.addExtra(node, "raw", this.input.slice(this.offsetToSourcePos(node.start), this.state.end));
			node.pattern = value.pattern;
			node.flags = value.flags;
			this.next();
			return this.finishNode(node, "RegExpLiteral");
		}
		parseBooleanLiteral(value) {
			const node = this.startNode();
			node.value = value;
			this.next();
			return this.finishNode(node, "BooleanLiteral");
		}
		parseNullLiteral() {
			const node = this.startNode();
			this.next();
			return this.finishNode(node, "NullLiteral");
		}
		parseParenAndDistinguishExpression(canBeArrow) {
			const startLoc = this.state.startLoc;
			let val;
			this.next();
			this.expressionScope.enter(newArrowHeadScope());
			const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
			const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
			this.state.maybeInArrowParameters = true;
			this.state.inFSharpPipelineDirectBody = false;
			const innerStartLoc = this.state.startLoc;
			const exprList = [];
			const refExpressionErrors = new ExpressionErrors();
			let first = true;
			let spreadStartLoc;
			let optionalCommaStartLoc;
			while (!this.match(11)) {
				if (first) first = false;
				else {
					this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
					if (this.match(11)) {
						optionalCommaStartLoc = this.state.startLoc;
						break;
					}
				}
				if (this.match(21)) {
					const spreadNodeStartLoc = this.state.startLoc;
					spreadStartLoc = this.state.startLoc;
					exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));
					if (!this.checkCommaAfterRest(41)) break;
				} else exprList.push(this.parseMaybeAssignAllowInOrVoidPattern(11, refExpressionErrors, this.parseParenItem));
			}
			const innerEndLoc = this.state.lastTokEndLoc;
			this.expect(11);
			this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
			this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
			let arrowNode = this.startNodeAt(startLoc);
			if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
				this.checkDestructuringPrivate(refExpressionErrors);
				this.expressionScope.validateAsPattern();
				this.expressionScope.exit();
				this.parseArrowExpression(arrowNode, exprList, false);
				return arrowNode;
			}
			this.expressionScope.exit();
			if (!exprList.length) this.unexpected(this.state.lastTokStartLoc);
			if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);
			if (spreadStartLoc) this.unexpected(spreadStartLoc);
			this.checkExpressionErrors(refExpressionErrors, true);
			this.toReferencedListDeep(exprList, true);
			if (exprList.length > 1) {
				val = this.startNodeAt(innerStartLoc);
				val.expressions = exprList;
				this.finishNode(val, "SequenceExpression");
				this.resetEndLocation(val, innerEndLoc);
			} else val = exprList[0];
			return this.wrapParenthesis(startLoc, val);
		}
		wrapParenthesis(startLoc, expression) {
			if (!(this.optionFlags & 1024)) {
				this.addExtra(expression, "parenthesized", true);
				this.addExtra(expression, "parenStart", startLoc.index);
				this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
				return expression;
			}
			const parenExpression = this.startNodeAt(startLoc);
			parenExpression.expression = expression;
			return this.finishNode(parenExpression, "ParenthesizedExpression");
		}
		shouldParseArrow(params) {
			return !this.canInsertSemicolon();
		}
		parseArrow(node) {
			if (this.eat(19)) return node;
		}
		parseParenItem(node, startLoc) {
			return node;
		}
		parseNewOrNewTarget() {
			const node = this.startNode();
			this.next();
			if (this.match(16)) {
				const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
				this.next();
				const metaProp = this.parseMetaProperty(node, meta, "target");
				if (!this.scope.allowNewTarget) this.raise(Errors.UnexpectedNewTarget, metaProp);
				return metaProp;
			}
			return this.parseNew(node);
		}
		parseNew(node) {
			this.parseNewCallee(node);
			if (this.eat(10)) {
				const args = this.parseExprList(11);
				this.toReferencedList(args);
				node.arguments = args;
			} else node.arguments = [];
			return this.finishNode(node, "NewExpression");
		}
		parseNewCallee(node) {
			const isImport = this.match(83);
			const callee = this.parseNoCallExpr();
			node.callee = callee;
			if (isImport && callee.type === "ImportExpression" || callee.type === "Import") this.raise(Errors.ImportCallNotNewExpression, callee);
			if (callee.type === "Super") this.raise(Errors.SuperCallNotNewExpression, callee);
		}
		parseTemplateElement(isTagged) {
			const { start, startLoc, end, value } = this.state;
			const elemStart = start + 1;
			const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
			if (value === null) {
				if (!isTagged) this.raise(Errors.InvalidEscapeSequenceTemplate, createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1));
			}
			const isTail = this.match(24);
			const endOffset = isTail ? -1 : -2;
			const elemEnd = end + endOffset;
			elem.value = {
				raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"),
				cooked: value === null ? null : value.slice(1, endOffset)
			};
			elem.tail = isTail;
			this.next();
			const finishedNode = this.finishNode(elem, "TemplateElement");
			this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
			return finishedNode;
		}
		parseTemplate(isTagged) {
			const node = this.startNode();
			let curElt = this.parseTemplateElement(isTagged);
			const quasis = [curElt];
			const substitutions = [];
			while (!curElt.tail) {
				substitutions.push(this.parseTemplateSubstitution());
				this.readTemplateContinuation();
				quasis.push(curElt = this.parseTemplateElement(isTagged));
			}
			node.expressions = substitutions;
			node.quasis = quasis;
			return this.finishNode(node, "TemplateLiteral");
		}
		parseTemplateSubstitution() {
			return this.parseExpression();
		}
		parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
			if (isRecord) this.expectPlugin("recordAndTuple");
			const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
			this.state.inFSharpPipelineDirectBody = false;
			let sawProto = false;
			let first = true;
			const node = this.startNode();
			node.properties = [];
			this.next();
			while (!this.match(close)) {
				if (first) first = false;
				else {
					this.expect(12);
					if (this.match(close)) {
						this.addTrailingCommaExtraToNode(node);
						break;
					}
				}
				let prop;
				if (isPattern) prop = this.parseBindingProperty();
				else {
					prop = this.parsePropertyDefinition(refExpressionErrors);
					sawProto = this.checkProto(prop, isRecord, sawProto, refExpressionErrors);
				}
				if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") this.raise(Errors.InvalidRecordProperty, prop);
				if (prop.shorthand) this.addExtra(prop, "shorthand", true);
				node.properties.push(prop);
			}
			this.next();
			this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
			let type = "ObjectExpression";
			if (isPattern) type = "ObjectPattern";
			else if (isRecord) type = "RecordExpression";
			return this.finishNode(node, type);
		}
		addTrailingCommaExtraToNode(node) {
			this.addExtra(node, "trailingComma", this.state.lastTokStartLoc.index);
			this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false);
		}
		maybeAsyncOrAccessorProp(prop) {
			return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));
		}
		parsePropertyDefinition(refExpressionErrors) {
			let decorators = [];
			if (this.match(26)) {
				if (this.hasPlugin("decorators")) this.raise(Errors.UnsupportedPropertyDecorator, this.state.startLoc);
				while (this.match(26)) decorators.push(this.parseDecorator());
			}
			const prop = this.startNode();
			let isAsync = false;
			let isAccessor = false;
			let startLoc;
			if (this.match(21)) {
				if (decorators.length) this.unexpected();
				return this.parseSpread();
			}
			if (decorators.length) {
				prop.decorators = decorators;
				decorators = [];
			}
			prop.method = false;
			if (refExpressionErrors) startLoc = this.state.startLoc;
			let isGenerator = this.eat(55);
			this.parsePropertyNamePrefixOperator(prop);
			const containsEsc = this.state.containsEsc;
			this.parsePropertyName(prop, refExpressionErrors);
			if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
				const { key } = prop;
				const keyName = key.name;
				if (keyName === "async" && !this.hasPrecedingLineBreak()) {
					isAsync = true;
					this.resetPreviousNodeTrailingComments(key);
					isGenerator = this.eat(55);
					this.parsePropertyName(prop);
				}
				if (keyName === "get" || keyName === "set") {
					isAccessor = true;
					this.resetPreviousNodeTrailingComments(key);
					prop.kind = keyName;
					if (this.match(55)) {
						isGenerator = true;
						this.raise(Errors.AccessorIsGenerator, this.state.curPosition(), { kind: keyName });
						this.next();
					}
					this.parsePropertyName(prop);
				}
			}
			return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
		}
		getGetterSetterExpectedParamCount(method) {
			return method.kind === "get" ? 0 : 1;
		}
		getObjectOrClassMethodParams(method) {
			return method.params;
		}
		checkGetterSetterParams(method) {
			var _params;
			const paramCount = this.getGetterSetterExpectedParamCount(method);
			const params = this.getObjectOrClassMethodParams(method);
			if (params.length !== paramCount) this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, method);
			if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") this.raise(Errors.BadSetterRestParameter, method);
		}
		parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
			if (isAccessor) {
				const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
				this.checkGetterSetterParams(finishedProp);
				return finishedProp;
			}
			if (isAsync || isGenerator || this.match(10)) {
				if (isPattern) this.unexpected();
				prop.kind = "method";
				prop.method = true;
				return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
			}
		}
		parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
			prop.shorthand = false;
			if (this.eat(14)) {
				prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowInOrVoidPattern(8, refExpressionErrors);
				return this.finishObjectProperty(prop);
			}
			if (!prop.computed && prop.key.type === "Identifier") {
				this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
				if (isPattern) prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));
				else if (this.match(29)) {
					const shorthandAssignLoc = this.state.startLoc;
					if (refExpressionErrors != null) {
						if (refExpressionErrors.shorthandAssignLoc === null) refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
					} else this.raise(Errors.InvalidCoverInitializedName, shorthandAssignLoc);
					prop.value = this.parseMaybeDefault(startLoc, this.cloneIdentifier(prop.key));
				} else prop.value = this.cloneIdentifier(prop.key);
				prop.shorthand = true;
				return this.finishObjectProperty(prop);
			}
		}
		finishObjectProperty(node) {
			return this.finishNode(node, "ObjectProperty");
		}
		parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
			const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
			if (!node) this.unexpected();
			return node;
		}
		parsePropertyName(prop, refExpressionErrors) {
			if (this.eat(0)) {
				prop.computed = true;
				prop.key = this.parseMaybeAssignAllowIn();
				this.expect(3);
			} else {
				const { type, value } = this.state;
				let key;
				if (tokenIsKeywordOrIdentifier(type)) key = this.parseIdentifier(true);
				else switch (type) {
					case 135:
						key = this.parseNumericLiteral(value);
						break;
					case 134:
						key = this.parseStringLiteral(value);
						break;
					case 136:
						key = this.parseBigIntLiteral(value);
						break;
					case 139: {
						const privateKeyLoc = this.state.startLoc;
						if (refExpressionErrors != null) {
							if (refExpressionErrors.privateKeyLoc === null) refExpressionErrors.privateKeyLoc = privateKeyLoc;
						} else this.raise(Errors.UnexpectedPrivateField, privateKeyLoc);
						key = this.parsePrivateName();
						break;
					}
					default:
						if (type === 137) {
							key = this.parseDecimalLiteral(value);
							break;
						}
						this.unexpected();
				}
				prop.key = key;
				if (type !== 139) prop.computed = false;
			}
		}
		initFunction(node, isAsync) {
			node.id = null;
			node.generator = false;
			node.async = isAsync;
		}
		parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
			this.initFunction(node, isAsync);
			node.generator = isGenerator;
			this.scope.enter(530 | (inClassScope ? 576 : 0) | (allowDirectSuper ? 32 : 0));
			this.prodParam.enter(functionFlags(isAsync, node.generator));
			this.parseFunctionParams(node, isConstructor);
			const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
			this.prodParam.exit();
			this.scope.exit();
			return finishedNode;
		}
		parseArrayLike(close, isTuple, refExpressionErrors) {
			if (isTuple) this.expectPlugin("recordAndTuple");
			const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
			this.state.inFSharpPipelineDirectBody = false;
			const node = this.startNode();
			this.next();
			node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);
			this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
			return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
		}
		parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
			this.scope.enter(518);
			let flags = functionFlags(isAsync, false);
			if (!this.match(5) && this.prodParam.hasIn) flags |= 8;
			this.prodParam.enter(flags);
			this.initFunction(node, isAsync);
			const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
			if (params) {
				this.state.maybeInArrowParameters = true;
				this.setArrowFunctionParameters(node, params, trailingCommaLoc);
			}
			this.state.maybeInArrowParameters = false;
			this.parseFunctionBody(node, true);
			this.prodParam.exit();
			this.scope.exit();
			this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
			return this.finishNode(node, "ArrowFunctionExpression");
		}
		setArrowFunctionParameters(node, params, trailingCommaLoc) {
			this.toAssignableList(params, trailingCommaLoc, false);
			node.params = params;
		}
		parseFunctionBodyAndFinish(node, type, isMethod = false) {
			this.parseFunctionBody(node, false, isMethod);
			return this.finishNode(node, type);
		}
		parseFunctionBody(node, allowExpression, isMethod = false) {
			const isExpression = allowExpression && !this.match(5);
			this.expressionScope.enter(newExpressionScope());
			if (isExpression) {
				node.body = this.parseMaybeAssign();
				this.checkParams(node, false, allowExpression, false);
			} else {
				const oldStrict = this.state.strict;
				const oldLabels = this.state.labels;
				this.state.labels = [];
				this.prodParam.enter(this.prodParam.currentFlags() | 4);
				node.body = this.parseBlock(true, false, (hasStrictModeDirective) => {
					const nonSimple = !this.isSimpleParamList(node.params);
					if (hasStrictModeDirective && nonSimple) this.raise(Errors.IllegalLanguageModeDirective, (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node);
					const strictModeChanged = !oldStrict && this.state.strict;
					this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
					if (this.state.strict && node.id) this.checkIdentifier(node.id, 65, strictModeChanged);
				});
				this.prodParam.exit();
				this.state.labels = oldLabels;
			}
			this.expressionScope.exit();
		}
		isSimpleParameter(node) {
			return node.type === "Identifier";
		}
		isSimpleParamList(params) {
			for (let i = 0, len = params.length; i < len; i++) if (!this.isSimpleParameter(params[i])) return false;
			return true;
		}
		checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
			const checkClashes = !allowDuplicates && /* @__PURE__ */ new Set();
			const formalParameters = { type: "FormalParameters" };
			for (const param of node.params) this.checkLVal(param, formalParameters, 5, checkClashes, strictModeChanged);
		}
		parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {
			const elts = [];
			let first = true;
			while (!this.eat(close)) {
				if (first) first = false;
				else {
					this.expect(12);
					if (this.match(close)) {
						if (nodeForExtra) this.addTrailingCommaExtraToNode(nodeForExtra);
						this.next();
						break;
					}
				}
				elts.push(this.parseExprListItem(close, allowEmpty, refExpressionErrors));
			}
			return elts;
		}
		parseExprListItem(close, allowEmpty, refExpressionErrors, allowPlaceholder) {
			let elt;
			if (this.match(12)) {
				if (!allowEmpty) this.raise(Errors.UnexpectedToken, this.state.curPosition(), { unexpected: "," });
				elt = null;
			} else if (this.match(21)) {
				const spreadNodeStartLoc = this.state.startLoc;
				elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
			} else if (this.match(17)) {
				this.expectPlugin("partialApplication");
				if (!allowPlaceholder) this.raise(Errors.UnexpectedArgumentPlaceholder, this.state.startLoc);
				const node = this.startNode();
				this.next();
				elt = this.finishNode(node, "ArgumentPlaceholder");
			} else elt = this.parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, this.parseParenItem);
			return elt;
		}
		parseIdentifier(liberal) {
			const node = this.startNode();
			const name = this.parseIdentifierName(liberal);
			return this.createIdentifier(node, name);
		}
		createIdentifier(node, name) {
			node.name = name;
			node.loc.identifierName = name;
			return this.finishNode(node, "Identifier");
		}
		createIdentifierAt(node, name, endLoc) {
			node.name = name;
			node.loc.identifierName = name;
			return this.finishNodeAt(node, "Identifier", endLoc);
		}
		parseIdentifierName(liberal) {
			let name;
			const { startLoc, type } = this.state;
			if (tokenIsKeywordOrIdentifier(type)) name = this.state.value;
			else this.unexpected();
			const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
			if (liberal) {
				if (tokenIsKeyword) this.replaceToken(132);
			} else this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
			this.next();
			return name;
		}
		checkReservedWord(word, startLoc, checkKeywords, isBinding) {
			if (word.length > 10) return;
			if (!canBeReservedWord(word)) return;
			if (checkKeywords && isKeyword(word)) {
				this.raise(Errors.UnexpectedKeyword, startLoc, { keyword: word });
				return;
			}
			if ((!this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord)(word, this.inModule)) {
				this.raise(Errors.UnexpectedReservedWord, startLoc, { reservedWord: word });
				return;
			} else if (word === "yield") {
				if (this.prodParam.hasYield) {
					this.raise(Errors.YieldBindingIdentifier, startLoc);
					return;
				}
			} else if (word === "await") {
				if (this.prodParam.hasAwait) {
					this.raise(Errors.AwaitBindingIdentifier, startLoc);
					return;
				}
				if (this.scope.inStaticBlock) {
					this.raise(Errors.AwaitBindingIdentifierInStaticBlock, startLoc);
					return;
				}
				this.expressionScope.recordAsyncArrowParametersError(startLoc);
			} else if (word === "arguments") {
				if (this.scope.inClassAndNotInNonArrowFunction) {
					this.raise(Errors.ArgumentsInClass, startLoc);
					return;
				}
			}
		}
		recordAwaitIfAllowed() {
			const isAwaitAllowed = this.prodParam.hasAwait;
			if (isAwaitAllowed && !this.scope.inFunction) this.state.hasTopLevelAwait = true;
			return isAwaitAllowed;
		}
		parseAwait(startLoc) {
			const node = this.startNodeAt(startLoc);
			this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, node);
			if (this.eat(55)) this.raise(Errors.ObsoleteAwaitStar, node);
			if (!this.scope.inFunction && !(this.optionFlags & 1)) {
				if (this.isAmbiguousPrefixOrIdentifier()) this.ambiguousScriptDifferentAst = true;
				else this.sawUnambiguousESM = true;
			}
			if (!this.state.soloAwait) node.argument = this.parseMaybeUnary(null, true);
			return this.finishNode(node, "AwaitExpression");
		}
		isAmbiguousPrefixOrIdentifier() {
			if (this.hasPrecedingLineBreak()) return true;
			const { type } = this.state;
			return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 102 && !this.state.containsEsc || type === 138 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
		}
		parseYield(startLoc) {
			const node = this.startNodeAt(startLoc);
			this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, node);
			let delegating = false;
			let argument = null;
			if (!this.hasPrecedingLineBreak()) {
				delegating = this.eat(55);
				switch (this.state.type) {
					case 13:
					case 140:
					case 8:
					case 11:
					case 3:
					case 9:
					case 14:
					case 12: if (!delegating) break;
					default: argument = this.parseMaybeAssign();
				}
			}
			node.delegate = delegating;
			node.argument = argument;
			return this.finishNode(node, "YieldExpression");
		}
		parseImportCall(node) {
			this.next();
			node.source = this.parseMaybeAssignAllowIn();
			node.options = null;
			if (this.eat(12)) {
				if (!this.match(11)) {
					node.options = this.parseMaybeAssignAllowIn();
					if (this.eat(12)) {
						this.addTrailingCommaExtraToNode(node.options);
						if (!this.match(11)) {
							do
								this.parseMaybeAssignAllowIn();
							while (this.eat(12) && !this.match(11));
							this.raise(Errors.ImportCallArity, node);
						}
					}
				} else this.addTrailingCommaExtraToNode(node.source);
			}
			this.expect(11);
			return this.finishNode(node, "ImportExpression");
		}
		checkPipelineAtInfixOperator(left, leftStartLoc) {
			if (this.hasPlugin(["pipelineOperator", { proposal: "smart" }])) {
				if (left.type === "SequenceExpression") this.raise(Errors.PipelineHeadSequenceExpression, leftStartLoc);
			}
		}
		parseSmartPipelineBodyInStyle(childExpr, startLoc) {
			if (this.isSimpleReference(childExpr)) {
				const bodyNode = this.startNodeAt(startLoc);
				bodyNode.callee = childExpr;
				return this.finishNode(bodyNode, "PipelineBareFunction");
			} else {
				const bodyNode = this.startNodeAt(startLoc);
				this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
				bodyNode.expression = childExpr;
				return this.finishNode(bodyNode, "PipelineTopicExpression");
			}
		}
		isSimpleReference(expression) {
			switch (expression.type) {
				case "MemberExpression": return !expression.computed && this.isSimpleReference(expression.object);
				case "Identifier": return true;
				default: return false;
			}
		}
		checkSmartPipeTopicBodyEarlyErrors(startLoc) {
			if (this.match(19)) throw this.raise(Errors.PipelineBodyNoArrow, this.state.startLoc);
			if (!this.topicReferenceWasUsedInCurrentContext()) this.raise(Errors.PipelineTopicUnused, startLoc);
		}
		withTopicBindingContext(callback) {
			const outerContextTopicState = this.state.topicContext;
			this.state.topicContext = {
				maxNumOfResolvableTopics: 1,
				maxTopicIndex: null
			};
			try {
				return callback();
			} finally {
				this.state.topicContext = outerContextTopicState;
			}
		}
		withSmartMixTopicForbiddingContext(callback) {
			if (this.hasPlugin(["pipelineOperator", { proposal: "smart" }])) {
				const outerContextTopicState = this.state.topicContext;
				this.state.topicContext = {
					maxNumOfResolvableTopics: 0,
					maxTopicIndex: null
				};
				try {
					return callback();
				} finally {
					this.state.topicContext = outerContextTopicState;
				}
			} else return callback();
		}
		withSoloAwaitPermittingContext(callback) {
			const outerContextSoloAwaitState = this.state.soloAwait;
			this.state.soloAwait = true;
			try {
				return callback();
			} finally {
				this.state.soloAwait = outerContextSoloAwaitState;
			}
		}
		allowInAnd(callback) {
			const flags = this.prodParam.currentFlags();
			if (8 & ~flags) {
				this.prodParam.enter(flags | 8);
				try {
					return callback();
				} finally {
					this.prodParam.exit();
				}
			}
			return callback();
		}
		disallowInAnd(callback) {
			const flags = this.prodParam.currentFlags();
			if (8 & flags) {
				this.prodParam.enter(flags & -9);
				try {
					return callback();
				} finally {
					this.prodParam.exit();
				}
			}
			return callback();
		}
		registerTopicReference() {
			this.state.topicContext.maxTopicIndex = 0;
		}
		topicReferenceIsAllowedInCurrentContext() {
			return this.state.topicContext.maxNumOfResolvableTopics >= 1;
		}
		topicReferenceWasUsedInCurrentContext() {
			return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
		}
		parseFSharpPipelineBody(prec) {
			const startLoc = this.state.startLoc;
			this.state.potentialArrowAt = this.state.start;
			const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
			this.state.inFSharpPipelineDirectBody = true;
			const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
			this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
			return ret;
		}
		parseModuleExpression() {
			this.expectPlugin("moduleBlocks");
			const node = this.startNode();
			this.next();
			if (!this.match(5)) this.unexpected(null, 5);
			const program = this.startNodeAt(this.state.endLoc);
			this.next();
			const revertScopes = this.initializeScopes(true);
			this.enterInitialScopes();
			try {
				node.body = this.parseProgram(program, 8, "module");
			} finally {
				revertScopes();
			}
			return this.finishNode(node, "ModuleExpression");
		}
		parseVoidPattern(refExpressionErrors) {
			this.expectPlugin("discardBinding");
			const node = this.startNode();
			if (refExpressionErrors != null) refExpressionErrors.voidPatternLoc = this.state.startLoc;
			this.next();
			return this.finishNode(node, "VoidPattern");
		}
		parseMaybeAssignAllowInOrVoidPattern(close, refExpressionErrors, afterLeftParse) {
			if (refExpressionErrors != null && this.match(88)) {
				const nextCode = this.lookaheadCharCode();
				if (nextCode === 44 || nextCode === (close === 3 ? 93 : close === 8 ? 125 : 41) || nextCode === 61) return this.parseMaybeDefault(this.state.startLoc, this.parseVoidPattern(refExpressionErrors));
			}
			return this.parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse);
		}
		parsePropertyNamePrefixOperator(prop) {}
	};
	const loopLabel = { kind: 1 };
	const switchLabel = { kind: 2 };
	const loneSurrogate = /[\uD800-\uDFFF]/u;
	const keywordRelationalOperator = /in(?:stanceof)?/y;
	function babel7CompatTokens(tokens, input, startIndex) {
		for (let i = 0; i < tokens.length; i++) {
			const token = tokens[i];
			const { type } = token;
			if (typeof type === "number") {
				if (type === 139) {
					const { loc, start, value, end } = token;
					const hashEndPos = start + 1;
					const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);
					tokens.splice(i, 1, new Token({
						type: getExportedToken(27),
						value: "#",
						start,
						end: hashEndPos,
						startLoc: loc.start,
						endLoc: hashEndLoc
					}), new Token({
						type: getExportedToken(132),
						value,
						start: hashEndPos,
						end,
						startLoc: hashEndLoc,
						endLoc: loc.end
					}));
					i++;
					continue;
				}
				if (tokenIsTemplate(type)) {
					const { loc, start, value, end } = token;
					const backquoteEnd = start + 1;
					const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);
					let startToken;
					if (input.charCodeAt(start - startIndex) === 96) startToken = new Token({
						type: getExportedToken(22),
						value: "`",
						start,
						end: backquoteEnd,
						startLoc: loc.start,
						endLoc: backquoteEndLoc
					});
					else startToken = new Token({
						type: getExportedToken(8),
						value: "}",
						start,
						end: backquoteEnd,
						startLoc: loc.start,
						endLoc: backquoteEndLoc
					});
					let templateValue, templateElementEnd, templateElementEndLoc, endToken;
					if (type === 24) {
						templateElementEnd = end - 1;
						templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);
						templateValue = value === null ? null : value.slice(1, -1);
						endToken = new Token({
							type: getExportedToken(22),
							value: "`",
							start: templateElementEnd,
							end,
							startLoc: templateElementEndLoc,
							endLoc: loc.end
						});
					} else {
						templateElementEnd = end - 2;
						templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);
						templateValue = value === null ? null : value.slice(1, -2);
						endToken = new Token({
							type: getExportedToken(23),
							value: "${",
							start: templateElementEnd,
							end,
							startLoc: templateElementEndLoc,
							endLoc: loc.end
						});
					}
					tokens.splice(i, 1, startToken, new Token({
						type: getExportedToken(20),
						value: templateValue,
						start: backquoteEnd,
						end: templateElementEnd,
						startLoc: backquoteEndLoc,
						endLoc: templateElementEndLoc
					}), endToken);
					i += 2;
					continue;
				}
				token.type = getExportedToken(type);
			}
		}
		return tokens;
	}
	var StatementParser = class extends ExpressionParser {
		parseTopLevel(file, program) {
			file.program = this.parseProgram(program, 140, this.options.sourceType === "module" ? "module" : "script");
			file.comments = this.comments;
			if (this.optionFlags & 256) file.tokens = babel7CompatTokens(this.tokens, this.input, this.startIndex);
			return this.finishNode(file, "File");
		}
		parseProgram(program, end, sourceType) {
			program.sourceType = sourceType;
			program.interpreter = this.parseInterpreterDirective();
			this.parseBlockBody(program, true, true, end);
			if (this.inModule) {
				if (!(this.optionFlags & 64) && this.scope.undefinedExports.size > 0) for (const [localName, at] of Array.from(this.scope.undefinedExports)) this.raise(Errors.ModuleExportUndefined, at, { localName });
				this.addExtra(program, "topLevelAwait", this.state.hasTopLevelAwait);
			}
			let finishedProgram;
			if (end === 140) finishedProgram = this.finishNode(program, "Program");
			else finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1));
			return finishedProgram;
		}
		stmtToDirective(stmt) {
			const directive = this.castNodeTo(stmt, "Directive");
			const directiveLiteral = this.castNodeTo(stmt.expression, "DirectiveLiteral");
			const expressionValue = directiveLiteral.value;
			const raw = this.input.slice(this.offsetToSourcePos(directiveLiteral.start), this.offsetToSourcePos(directiveLiteral.end));
			const val = directiveLiteral.value = raw.slice(1, -1);
			this.addExtra(directiveLiteral, "raw", raw);
			this.addExtra(directiveLiteral, "rawValue", val);
			this.addExtra(directiveLiteral, "expressionValue", expressionValue);
			directive.value = directiveLiteral;
			delete stmt.expression;
			return directive;
		}
		parseInterpreterDirective() {
			if (!this.match(28)) return null;
			const node = this.startNode();
			node.value = this.state.value;
			this.next();
			return this.finishNode(node, "InterpreterDirective");
		}
		isLet() {
			if (!this.isContextual(100)) return false;
			return this.hasFollowingBindingAtom();
		}
		isUsing() {
			if (!this.isContextual(107)) return false;
			return this.nextTokenIsIdentifierOnSameLine();
		}
		isForUsing() {
			if (!this.isContextual(107)) return false;
			const next = this.nextTokenInLineStart();
			const nextCh = this.codePointAtPos(next);
			if (this.isUnparsedContextual(next, "of")) {
				const nextCharAfterOf = this.lookaheadCharCodeSince(next + 2);
				if (nextCharAfterOf !== 61 && nextCharAfterOf !== 58 && nextCharAfterOf !== 59) return false;
			}
			if (this.chStartsBindingIdentifier(nextCh, next) || this.isUnparsedContextual(next, "void")) return true;
			return false;
		}
		nextTokenIsIdentifierOnSameLine() {
			const next = this.nextTokenInLineStart();
			const nextCh = this.codePointAtPos(next);
			return this.chStartsBindingIdentifier(nextCh, next);
		}
		isAwaitUsing() {
			if (!this.isContextual(96)) return false;
			let next = this.nextTokenInLineStart();
			if (this.isUnparsedContextual(next, "using")) {
				next = this.nextTokenInLineStartSince(next + 5);
				const nextCh = this.codePointAtPos(next);
				if (this.chStartsBindingIdentifier(nextCh, next)) return true;
			}
			return false;
		}
		chStartsBindingIdentifier(ch, pos) {
			if (isIdentifierStart(ch)) {
				keywordRelationalOperator.lastIndex = pos;
				if (keywordRelationalOperator.test(this.input)) {
					const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
					if (!isIdentifierChar(endCh) && endCh !== 92) return false;
				}
				return true;
			} else if (ch === 92) return true;
			else return false;
		}
		chStartsBindingPattern(ch) {
			return ch === 91 || ch === 123;
		}
		hasFollowingBindingAtom() {
			const next = this.nextTokenStart();
			const nextCh = this.codePointAtPos(next);
			return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
		}
		hasInLineFollowingBindingIdentifierOrBrace() {
			const next = this.nextTokenInLineStart();
			const nextCh = this.codePointAtPos(next);
			return nextCh === 123 || this.chStartsBindingIdentifier(nextCh, next);
		}
		allowsUsing() {
			return (this.scope.inModule || !this.scope.inTopLevel) && !this.scope.inBareCaseStatement;
		}
		parseModuleItem() {
			return this.parseStatementLike(15);
		}
		parseStatementListItem() {
			return this.parseStatementLike(6 | (!this.options.annexB || this.state.strict ? 0 : 8));
		}
		parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
			let flags = 0;
			if (this.options.annexB && !this.state.strict) {
				flags |= 4;
				if (allowLabeledFunction) flags |= 8;
			}
			return this.parseStatementLike(flags);
		}
		parseStatement() {
			return this.parseStatementLike(0);
		}
		parseStatementLike(flags) {
			let decorators = null;
			if (this.match(26)) decorators = this.parseDecorators(true);
			return this.parseStatementContent(flags, decorators);
		}
		parseStatementContent(flags, decorators) {
			const startType = this.state.type;
			const node = this.startNode();
			const allowDeclaration = !!(flags & 2);
			const allowFunctionDeclaration = !!(flags & 4);
			const topLevel = flags & 1;
			switch (startType) {
				case 60: return this.parseBreakContinueStatement(node, true);
				case 63: return this.parseBreakContinueStatement(node, false);
				case 64: return this.parseDebuggerStatement(node);
				case 90: return this.parseDoWhileStatement(node);
				case 91: return this.parseForStatement(node);
				case 68:
					if (this.lookaheadCharCode() === 46) break;
					if (!allowFunctionDeclaration) this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, this.state.startLoc);
					return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
				case 80:
					if (!allowDeclaration) this.unexpected();
					return this.parseClass(this.maybeTakeDecorators(decorators, node), true);
				case 69: return this.parseIfStatement(node);
				case 70: return this.parseReturnStatement(node);
				case 71: return this.parseSwitchStatement(node);
				case 72: return this.parseThrowStatement(node);
				case 73: return this.parseTryStatement(node);
				case 96:
					if (this.isAwaitUsing()) {
						if (!this.allowsUsing()) this.raise(Errors.UnexpectedUsingDeclaration, node);
						else if (!allowDeclaration) this.raise(Errors.UnexpectedLexicalDeclaration, node);
						else if (!this.recordAwaitIfAllowed()) this.raise(Errors.AwaitUsingNotInAsyncContext, node);
						this.next();
						return this.parseVarStatement(node, "await using");
					}
					break;
				case 107:
					if (this.state.containsEsc || !this.hasInLineFollowingBindingIdentifierOrBrace()) break;
					if (!this.allowsUsing()) this.raise(Errors.UnexpectedUsingDeclaration, this.state.startLoc);
					else if (!allowDeclaration) this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
					return this.parseVarStatement(node, "using");
				case 100: {
					if (this.state.containsEsc) break;
					const next = this.nextTokenStart();
					const nextCh = this.codePointAtPos(next);
					if (nextCh !== 91) {
						if (!allowDeclaration && this.hasFollowingLineBreak()) break;
						if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) break;
					}
				}
				case 75: if (!allowDeclaration) this.raise(Errors.UnexpectedLexicalDeclaration, this.state.startLoc);
				case 74: {
					const kind = this.state.value;
					return this.parseVarStatement(node, kind);
				}
				case 92: return this.parseWhileStatement(node);
				case 76: return this.parseWithStatement(node);
				case 5: return this.parseBlock();
				case 13: return this.parseEmptyStatement(node);
				case 83: {
					const nextTokenCharCode = this.lookaheadCharCode();
					if (nextTokenCharCode === 40 || nextTokenCharCode === 46) break;
				}
				case 82: {
					if (!(this.optionFlags & 8) && !topLevel) this.raise(Errors.UnexpectedImportExport, this.state.startLoc);
					this.next();
					let result;
					if (startType === 83) result = this.parseImport(node);
					else result = this.parseExport(node, decorators);
					this.assertModuleNodeAllowed(result);
					return result;
				}
				default: if (this.isAsyncFunction()) {
					if (!allowDeclaration) this.raise(Errors.AsyncFunctionInSingleStatementContext, this.state.startLoc);
					this.next();
					return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
				}
			}
			const maybeName = this.state.value;
			const expr = this.parseExpression();
			if (tokenIsIdentifier(startType) && expr.type === "Identifier" && this.eat(14)) return this.parseLabeledStatement(node, maybeName, expr, flags);
			else return this.parseExpressionStatement(node, expr, decorators);
		}
		assertModuleNodeAllowed(node) {
			if (!(this.optionFlags & 8) && !this.inModule) this.raise(Errors.ImportOutsideModule, node);
		}
		decoratorsEnabledBeforeExport() {
			if (this.hasPlugin("decorators-legacy")) return true;
			return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
		}
		maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
			if (maybeDecorators) {
				var _classNode$decorators;
				if ((_classNode$decorators = classNode.decorators) != null && _classNode$decorators.length) {
					if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") this.raise(Errors.DecoratorsBeforeAfterExport, classNode.decorators[0]);
					classNode.decorators.unshift(...maybeDecorators);
				} else classNode.decorators = maybeDecorators;
				this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
				if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);
			}
			return classNode;
		}
		canHaveLeadingDecorator() {
			return this.match(80);
		}
		parseDecorators(allowExport) {
			const decorators = [];
			do
				decorators.push(this.parseDecorator());
			while (this.match(26));
			if (this.match(82)) {
				if (!allowExport) this.unexpected();
				if (!this.decoratorsEnabledBeforeExport()) this.raise(Errors.DecoratorExportClass, this.state.startLoc);
			} else if (!this.canHaveLeadingDecorator()) throw this.raise(Errors.UnexpectedLeadingDecorator, this.state.startLoc);
			return decorators;
		}
		parseDecorator() {
			this.expectOnePlugin(["decorators", "decorators-legacy"]);
			const node = this.startNode();
			this.next();
			if (this.hasPlugin("decorators")) {
				const startLoc = this.state.startLoc;
				let expr;
				if (this.match(10)) {
					const startLoc = this.state.startLoc;
					this.next();
					expr = this.parseExpression();
					this.expect(11);
					expr = this.wrapParenthesis(startLoc, expr);
					const paramsStartLoc = this.state.startLoc;
					node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
					if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) this.raise(Errors.DecoratorArgumentsOutsideParentheses, paramsStartLoc);
				} else {
					expr = this.parseIdentifier(false);
					while (this.eat(16)) {
						const node = this.startNodeAt(startLoc);
						node.object = expr;
						if (this.match(139)) {
							this.classScope.usePrivateName(this.state.value, this.state.startLoc);
							node.property = this.parsePrivateName();
						} else node.property = this.parseIdentifier(true);
						node.computed = false;
						expr = this.finishNode(node, "MemberExpression");
					}
					node.expression = this.parseMaybeDecoratorArguments(expr, startLoc);
				}
			} else node.expression = this.parseExprSubscripts();
			return this.finishNode(node, "Decorator");
		}
		parseMaybeDecoratorArguments(expr, startLoc) {
			if (this.eat(10)) {
				const node = this.startNodeAt(startLoc);
				node.callee = expr;
				node.arguments = this.parseCallExpressionArguments();
				this.toReferencedList(node.arguments);
				return this.finishNode(node, "CallExpression");
			}
			return expr;
		}
		parseBreakContinueStatement(node, isBreak) {
			this.next();
			if (this.isLineTerminator()) node.label = null;
			else {
				node.label = this.parseIdentifier();
				this.semicolon();
			}
			this.verifyBreakContinue(node, isBreak);
			return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
		}
		verifyBreakContinue(node, isBreak) {
			let i;
			for (i = 0; i < this.state.labels.length; ++i) {
				const lab = this.state.labels[i];
				if (node.label == null || lab.name === node.label.name) {
					if (lab.kind != null && (isBreak || lab.kind === 1)) break;
					if (node.label && isBreak) break;
				}
			}
			if (i === this.state.labels.length) {
				const type = isBreak ? "BreakStatement" : "ContinueStatement";
				this.raise(Errors.IllegalBreakContinue, node, { type });
			}
		}
		parseDebuggerStatement(node) {
			this.next();
			this.semicolon();
			return this.finishNode(node, "DebuggerStatement");
		}
		parseHeaderExpression() {
			this.expect(10);
			const val = this.parseExpression();
			this.expect(11);
			return val;
		}
		parseDoWhileStatement(node) {
			this.next();
			this.state.labels.push(loopLabel);
			node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
			this.state.labels.pop();
			this.expect(92);
			node.test = this.parseHeaderExpression();
			this.eat(13);
			return this.finishNode(node, "DoWhileStatement");
		}
		parseForStatement(node) {
			this.next();
			this.state.labels.push(loopLabel);
			let awaitAt = null;
			if (this.isContextual(96) && this.recordAwaitIfAllowed()) {
				awaitAt = this.state.startLoc;
				this.next();
			}
			this.scope.enter(0);
			this.expect(10);
			if (this.match(13)) {
				if (awaitAt !== null) this.unexpected(awaitAt);
				return this.parseFor(node, null);
			}
			const startsWithLet = this.isContextual(100);
			{
				const startsWithAwaitUsing = this.isAwaitUsing();
				const starsWithUsingDeclaration = startsWithAwaitUsing || this.isForUsing();
				const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || starsWithUsingDeclaration;
				if (this.match(74) || this.match(75) || isLetOrUsing) {
					const initNode = this.startNode();
					let kind;
					if (startsWithAwaitUsing) {
						kind = "await using";
						if (!this.recordAwaitIfAllowed()) this.raise(Errors.AwaitUsingNotInAsyncContext, this.state.startLoc);
						this.next();
					} else kind = this.state.value;
					this.next();
					this.parseVar(initNode, true, kind);
					const init = this.finishNode(initNode, "VariableDeclaration");
					const isForIn = this.match(58);
					if (isForIn && starsWithUsingDeclaration) this.raise(Errors.ForInUsing, init);
					if ((isForIn || this.isContextual(102)) && init.declarations.length === 1) return this.parseForIn(node, init, awaitAt);
					if (awaitAt !== null) this.unexpected(awaitAt);
					return this.parseFor(node, init);
				}
			}
			const startsWithAsync = this.isContextual(95);
			const refExpressionErrors = new ExpressionErrors();
			const init = this.parseExpression(true, refExpressionErrors);
			const isForOf = this.isContextual(102);
			if (isForOf) {
				if (startsWithLet) this.raise(Errors.ForOfLet, init);
				if (awaitAt === null && startsWithAsync && init.type === "Identifier") this.raise(Errors.ForOfAsync, init);
			}
			if (isForOf || this.match(58)) {
				this.checkDestructuringPrivate(refExpressionErrors);
				this.toAssignable(init, true);
				const type = isForOf ? "ForOfStatement" : "ForInStatement";
				this.checkLVal(init, { type });
				return this.parseForIn(node, init, awaitAt);
			} else this.checkExpressionErrors(refExpressionErrors, true);
			if (awaitAt !== null) this.unexpected(awaitAt);
			return this.parseFor(node, init);
		}
		parseFunctionStatement(node, isAsync, isHangingDeclaration) {
			this.next();
			return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));
		}
		parseIfStatement(node) {
			this.next();
			node.test = this.parseHeaderExpression();
			node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
			node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
			return this.finishNode(node, "IfStatement");
		}
		parseReturnStatement(node) {
			if (!this.prodParam.hasReturn) this.raise(Errors.IllegalReturn, this.state.startLoc);
			this.next();
			if (this.isLineTerminator()) node.argument = null;
			else {
				node.argument = this.parseExpression();
				this.semicolon();
			}
			return this.finishNode(node, "ReturnStatement");
		}
		parseSwitchStatement(node) {
			this.next();
			node.discriminant = this.parseHeaderExpression();
			const cases = node.cases = [];
			this.expect(5);
			this.state.labels.push(switchLabel);
			this.scope.enter(256);
			let cur;
			for (let sawDefault; !this.match(8);) if (this.match(61) || this.match(65)) {
				const isCase = this.match(61);
				if (cur) this.finishNode(cur, "SwitchCase");
				cases.push(cur = this.startNode());
				cur.consequent = [];
				this.next();
				if (isCase) cur.test = this.parseExpression();
				else {
					if (sawDefault) this.raise(Errors.MultipleDefaultsInSwitch, this.state.lastTokStartLoc);
					sawDefault = true;
					cur.test = null;
				}
				this.expect(14);
			} else if (cur) cur.consequent.push(this.parseStatementListItem());
			else this.unexpected();
			this.scope.exit();
			if (cur) this.finishNode(cur, "SwitchCase");
			this.next();
			this.state.labels.pop();
			return this.finishNode(node, "SwitchStatement");
		}
		parseThrowStatement(node) {
			this.next();
			if (this.hasPrecedingLineBreak()) this.raise(Errors.NewlineAfterThrow, this.state.lastTokEndLoc);
			node.argument = this.parseExpression();
			this.semicolon();
			return this.finishNode(node, "ThrowStatement");
		}
		parseCatchClauseParam() {
			const param = this.parseBindingAtom();
			this.scope.enter(this.options.annexB && param.type === "Identifier" ? 8 : 0);
			this.checkLVal(param, { type: "CatchClause" }, 9);
			return param;
		}
		parseTryStatement(node) {
			this.next();
			node.block = this.parseBlock();
			node.handler = null;
			if (this.match(62)) {
				const clause = this.startNode();
				this.next();
				if (this.match(10)) {
					this.expect(10);
					clause.param = this.parseCatchClauseParam();
					this.expect(11);
				} else {
					clause.param = null;
					this.scope.enter(0);
				}
				clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));
				this.scope.exit();
				node.handler = this.finishNode(clause, "CatchClause");
			}
			node.finalizer = this.eat(67) ? this.parseBlock() : null;
			if (!node.handler && !node.finalizer) this.raise(Errors.NoCatchOrFinally, node);
			return this.finishNode(node, "TryStatement");
		}
		parseVarStatement(node, kind, allowMissingInitializer = false) {
			this.next();
			this.parseVar(node, false, kind, allowMissingInitializer);
			this.semicolon();
			return this.finishNode(node, "VariableDeclaration");
		}
		parseWhileStatement(node) {
			this.next();
			node.test = this.parseHeaderExpression();
			this.state.labels.push(loopLabel);
			node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
			this.state.labels.pop();
			return this.finishNode(node, "WhileStatement");
		}
		parseWithStatement(node) {
			if (this.state.strict) this.raise(Errors.StrictWith, this.state.startLoc);
			this.next();
			node.object = this.parseHeaderExpression();
			node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
			return this.finishNode(node, "WithStatement");
		}
		parseEmptyStatement(node) {
			this.next();
			return this.finishNode(node, "EmptyStatement");
		}
		parseLabeledStatement(node, maybeName, expr, flags) {
			for (const label of this.state.labels) if (label.name === maybeName) this.raise(Errors.LabelRedeclaration, expr, { labelName: maybeName });
			const kind = tokenIsLoop(this.state.type) ? 1 : this.match(71) ? 2 : null;
			for (let i = this.state.labels.length - 1; i >= 0; i--) {
				const label = this.state.labels[i];
				if (label.statementStart === node.start) {
					label.statementStart = this.sourceToOffsetPos(this.state.start);
					label.kind = kind;
				} else break;
			}
			this.state.labels.push({
				name: maybeName,
				kind,
				statementStart: this.sourceToOffsetPos(this.state.start)
			});
			node.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
			this.state.labels.pop();
			node.label = expr;
			return this.finishNode(node, "LabeledStatement");
		}
		parseExpressionStatement(node, expr, decorators) {
			node.expression = expr;
			this.semicolon();
			return this.finishNode(node, "ExpressionStatement");
		}
		parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {
			const node = this.startNode();
			if (allowDirectives) this.state.strictErrors.clear();
			this.expect(5);
			if (createNewLexicalScope) this.scope.enter(0);
			this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);
			if (createNewLexicalScope) this.scope.exit();
			return this.finishNode(node, "BlockStatement");
		}
		isValidDirective(stmt) {
			return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
		}
		parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
			const body = node.body = [];
			const directives = node.directives = [];
			this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : void 0, topLevel, end, afterBlockParse);
		}
		parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {
			const oldStrict = this.state.strict;
			let hasStrictModeDirective = false;
			let parsedNonDirective = false;
			while (!this.match(end)) {
				const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
				if (directives && !parsedNonDirective) {
					if (this.isValidDirective(stmt)) {
						const directive = this.stmtToDirective(stmt);
						directives.push(directive);
						if (!hasStrictModeDirective && directive.value.value === "use strict") {
							hasStrictModeDirective = true;
							this.setStrict(true);
						}
						continue;
					}
					parsedNonDirective = true;
					this.state.strictErrors.clear();
				}
				body.push(stmt);
			}
			afterBlockParse == null || afterBlockParse.call(this, hasStrictModeDirective);
			if (!oldStrict) this.setStrict(false);
			this.next();
		}
		parseFor(node, init) {
			node.init = init;
			this.semicolon(false);
			node.test = this.match(13) ? null : this.parseExpression();
			this.semicolon(false);
			node.update = this.match(11) ? null : this.parseExpression();
			this.expect(11);
			node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
			this.scope.exit();
			this.state.labels.pop();
			return this.finishNode(node, "ForStatement");
		}
		parseForIn(node, init, awaitAt) {
			const isForIn = this.match(58);
			this.next();
			if (isForIn) {
				if (awaitAt !== null) this.unexpected(awaitAt);
			} else node.await = awaitAt !== null;
			if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) this.raise(Errors.ForInOfLoopInitializer, init, { type: isForIn ? "ForInStatement" : "ForOfStatement" });
			if (init.type === "AssignmentPattern") this.raise(Errors.InvalidLhs, init, { ancestor: { type: "ForStatement" } });
			node.left = init;
			node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
			this.expect(11);
			node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
			this.scope.exit();
			this.state.labels.pop();
			return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
		}
		parseVar(node, isFor, kind, allowMissingInitializer = false) {
			const declarations = node.declarations = [];
			node.kind = kind;
			for (;;) {
				const decl = this.startNode();
				this.parseVarId(decl, kind);
				decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
				if (decl.init === null && !allowMissingInitializer) {
					if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(102)))) this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind: "destructuring" });
					else if ((kind === "const" || kind === "using" || kind === "await using") && !(this.match(58) || this.isContextual(102))) this.raise(Errors.DeclarationMissingInitializer, this.state.lastTokEndLoc, { kind });
				}
				declarations.push(this.finishNode(decl, "VariableDeclarator"));
				if (!this.eat(12)) break;
			}
			return node;
		}
		parseVarId(decl, kind) {
			const id = this.parseBindingAtom();
			if (kind === "using" || kind === "await using") {
				if (id.type === "ArrayPattern" || id.type === "ObjectPattern") this.raise(Errors.UsingDeclarationHasBindingPattern, id.loc.start);
			} else if (id.type === "VoidPattern") this.raise(Errors.UnexpectedVoidPattern, id.loc.start);
			this.checkLVal(id, { type: "VariableDeclarator" }, kind === "var" ? 5 : 8201);
			decl.id = id;
		}
		parseAsyncFunctionExpression(node) {
			return this.parseFunction(node, 8);
		}
		parseFunction(node, flags = 0) {
			const hangingDeclaration = flags & 2;
			const isDeclaration = !!(flags & 1);
			const requireId = isDeclaration && !(flags & 4);
			const isAsync = !!(flags & 8);
			this.initFunction(node, isAsync);
			if (this.match(55)) {
				if (hangingDeclaration) this.raise(Errors.GeneratorInSingleStatementContext, this.state.startLoc);
				this.next();
				node.generator = true;
			}
			if (isDeclaration) node.id = this.parseFunctionId(requireId);
			const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
			this.state.maybeInArrowParameters = false;
			this.scope.enter(514);
			this.prodParam.enter(functionFlags(isAsync, node.generator));
			if (!isDeclaration) node.id = this.parseFunctionId();
			this.parseFunctionParams(node, false);
			this.withSmartMixTopicForbiddingContext(() => {
				this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
			});
			this.prodParam.exit();
			this.scope.exit();
			if (isDeclaration && !hangingDeclaration) this.registerFunctionStatementId(node);
			this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
			return node;
		}
		parseFunctionId(requireId) {
			return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
		}
		parseFunctionParams(node, isConstructor) {
			this.expect(10);
			this.expressionScope.enter(newParameterDeclarationScope());
			node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));
			this.expressionScope.exit();
		}
		registerFunctionStatementId(node) {
			if (!node.id) return;
			this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? 5 : 8201 : 17, node.id.loc.start);
		}
		parseClass(node, isStatement, optionalId) {
			this.next();
			const oldStrict = this.state.strict;
			this.state.strict = true;
			this.parseClassId(node, isStatement, optionalId);
			this.parseClassSuper(node);
			node.body = this.parseClassBody(!!node.superClass, oldStrict);
			return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
		}
		isClassProperty() {
			return this.match(29) || this.match(13) || this.match(8);
		}
		isClassMethod() {
			return this.match(10);
		}
		nameIsConstructor(key) {
			return key.type === "Identifier" && key.name === "constructor" || key.type === "StringLiteral" && key.value === "constructor";
		}
		isNonstaticConstructor(method) {
			return !method.computed && !method.static && this.nameIsConstructor(method.key);
		}
		parseClassBody(hadSuperClass, oldStrict) {
			this.classScope.enter();
			const state = {
				hadConstructor: false,
				hadSuperClass
			};
			let decorators = [];
			const classBody = this.startNode();
			classBody.body = [];
			this.expect(5);
			this.withSmartMixTopicForbiddingContext(() => {
				while (!this.match(8)) {
					if (this.eat(13)) {
						if (decorators.length > 0) throw this.raise(Errors.DecoratorSemicolon, this.state.lastTokEndLoc);
						continue;
					}
					if (this.match(26)) {
						decorators.push(this.parseDecorator());
						continue;
					}
					const member = this.startNode();
					if (decorators.length) {
						member.decorators = decorators;
						this.resetStartLocationFromNode(member, decorators[0]);
						decorators = [];
					}
					this.parseClassMember(classBody, member, state);
					if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) this.raise(Errors.DecoratorConstructor, member);
				}
			});
			this.state.strict = oldStrict;
			this.next();
			if (decorators.length) throw this.raise(Errors.TrailingDecorator, this.state.startLoc);
			this.classScope.exit();
			return this.finishNode(classBody, "ClassBody");
		}
		parseClassMemberFromModifier(classBody, member) {
			const key = this.parseIdentifier(true);
			if (this.isClassMethod()) {
				const method = member;
				method.kind = "method";
				method.computed = false;
				method.key = key;
				method.static = false;
				this.pushClassMethod(classBody, method, false, false, false, false);
				return true;
			} else if (this.isClassProperty()) {
				const prop = member;
				prop.computed = false;
				prop.key = key;
				prop.static = false;
				classBody.body.push(this.parseClassProperty(prop));
				return true;
			}
			this.resetPreviousNodeTrailingComments(key);
			return false;
		}
		parseClassMember(classBody, member, state) {
			const isStatic = this.isContextual(106);
			if (isStatic) {
				if (this.parseClassMemberFromModifier(classBody, member)) return;
				if (this.eat(5)) {
					this.parseClassStaticBlock(classBody, member);
					return;
				}
			}
			this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
		}
		parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
			const publicMethod = member;
			const privateMethod = member;
			const publicProp = member;
			const privateProp = member;
			const accessorProp = member;
			const method = publicMethod;
			const publicMember = publicMethod;
			member.static = isStatic;
			this.parsePropertyNamePrefixOperator(member);
			if (this.eat(55)) {
				method.kind = "method";
				const isPrivateName = this.match(139);
				this.parseClassElementName(method);
				this.parsePostMemberNameModifiers(method);
				if (isPrivateName) {
					this.pushClassPrivateMethod(classBody, privateMethod, true, false);
					return;
				}
				if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors.ConstructorIsGenerator, publicMethod.key);
				this.pushClassMethod(classBody, publicMethod, true, false, false, false);
				return;
			}
			const isContextual = !this.state.containsEsc && tokenIsIdentifier(this.state.type);
			const key = this.parseClassElementName(member);
			const maybeContextualKw = isContextual ? key.name : null;
			const isPrivate = this.isPrivateName(key);
			const maybeQuestionTokenStartLoc = this.state.startLoc;
			this.parsePostMemberNameModifiers(publicMember);
			if (this.isClassMethod()) {
				method.kind = "method";
				if (isPrivate) {
					this.pushClassPrivateMethod(classBody, privateMethod, false, false);
					return;
				}
				const isConstructor = this.isNonstaticConstructor(publicMethod);
				let allowsDirectSuper = false;
				if (isConstructor) {
					publicMethod.kind = "constructor";
					if (state.hadConstructor && !this.hasPlugin("typescript")) this.raise(Errors.DuplicateConstructor, key);
					if (isConstructor && this.hasPlugin("typescript") && member.override) this.raise(Errors.OverrideOnConstructor, key);
					state.hadConstructor = true;
					allowsDirectSuper = state.hadSuperClass;
				}
				this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
			} else if (this.isClassProperty()) {
				if (isPrivate) this.pushClassPrivateProperty(classBody, privateProp);
				else this.pushClassProperty(classBody, publicProp);
			} else if (maybeContextualKw === "async" && !this.isLineTerminator()) {
				this.resetPreviousNodeTrailingComments(key);
				const isGenerator = this.eat(55);
				if (publicMember.optional) this.unexpected(maybeQuestionTokenStartLoc);
				method.kind = "method";
				const isPrivate = this.match(139);
				this.parseClassElementName(method);
				this.parsePostMemberNameModifiers(publicMember);
				if (isPrivate) this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
				else {
					if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors.ConstructorIsAsync, publicMethod.key);
					this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
				}
			} else if ((maybeContextualKw === "get" || maybeContextualKw === "set") && !(this.match(55) && this.isLineTerminator())) {
				this.resetPreviousNodeTrailingComments(key);
				method.kind = maybeContextualKw;
				const isPrivate = this.match(139);
				this.parseClassElementName(publicMethod);
				if (isPrivate) this.pushClassPrivateMethod(classBody, privateMethod, false, false);
				else {
					if (this.isNonstaticConstructor(publicMethod)) this.raise(Errors.ConstructorIsAccessor, publicMethod.key);
					this.pushClassMethod(classBody, publicMethod, false, false, false, false);
				}
				this.checkGetterSetterParams(publicMethod);
			} else if (maybeContextualKw === "accessor" && !this.isLineTerminator()) {
				this.expectPlugin("decoratorAutoAccessors");
				this.resetPreviousNodeTrailingComments(key);
				const isPrivate = this.match(139);
				this.parseClassElementName(publicProp);
				this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);
			} else if (this.isLineTerminator()) {
				if (isPrivate) this.pushClassPrivateProperty(classBody, privateProp);
				else this.pushClassProperty(classBody, publicProp);
			} else this.unexpected();
		}
		parseClassElementName(member) {
			const { type, value } = this.state;
			if ((type === 132 || type === 134) && member.static && value === "prototype") this.raise(Errors.StaticPrototype, this.state.startLoc);
			if (type === 139) {
				if (value === "constructor") this.raise(Errors.ConstructorClassPrivateField, this.state.startLoc);
				const key = this.parsePrivateName();
				member.key = key;
				return key;
			}
			this.parsePropertyName(member);
			return member.key;
		}
		parseClassStaticBlock(classBody, member) {
			var _member$decorators;
			this.scope.enter(720);
			const oldLabels = this.state.labels;
			this.state.labels = [];
			this.prodParam.enter(0);
			const body = member.body = [];
			this.parseBlockOrModuleBlockBody(body, void 0, false, 8);
			this.prodParam.exit();
			this.scope.exit();
			this.state.labels = oldLabels;
			classBody.body.push(this.finishNode(member, "StaticBlock"));
			if ((_member$decorators = member.decorators) != null && _member$decorators.length) this.raise(Errors.DecoratorStaticBlock, member);
		}
		pushClassProperty(classBody, prop) {
			if (!prop.computed && this.nameIsConstructor(prop.key)) this.raise(Errors.ConstructorClassField, prop.key);
			classBody.body.push(this.parseClassProperty(prop));
		}
		pushClassPrivateProperty(classBody, prop) {
			const node = this.parseClassPrivateProperty(prop);
			classBody.body.push(node);
			this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
		}
		pushClassAccessorProperty(classBody, prop, isPrivate) {
			if (!isPrivate && !prop.computed && this.nameIsConstructor(prop.key)) this.raise(Errors.ConstructorClassField, prop.key);
			const node = this.parseClassAccessorProperty(prop);
			classBody.body.push(node);
			if (isPrivate) this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), 0, node.key.loc.start);
		}
		pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
			classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
		}
		pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
			const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true);
			classBody.body.push(node);
			const kind = node.kind === "get" ? node.static ? 6 : 2 : node.kind === "set" ? node.static ? 5 : 1 : 0;
			this.declareClassPrivateMethodInScope(node, kind);
		}
		declareClassPrivateMethodInScope(node, kind) {
			this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
		}
		parsePostMemberNameModifiers(methodOrProp) {}
		parseClassPrivateProperty(node) {
			this.parseInitializer(node);
			this.semicolon();
			return this.finishNode(node, "ClassPrivateProperty");
		}
		parseClassProperty(node) {
			this.parseInitializer(node);
			this.semicolon();
			return this.finishNode(node, "ClassProperty");
		}
		parseClassAccessorProperty(node) {
			this.parseInitializer(node);
			this.semicolon();
			return this.finishNode(node, "ClassAccessorProperty");
		}
		parseInitializer(node) {
			this.scope.enter(592);
			this.expressionScope.enter(newExpressionScope());
			this.prodParam.enter(0);
			node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
			this.expressionScope.exit();
			this.prodParam.exit();
			this.scope.exit();
		}
		parseClassId(node, isStatement, optionalId, bindingType = 8331) {
			if (tokenIsIdentifier(this.state.type)) {
				node.id = this.parseIdentifier();
				if (isStatement) this.declareNameFromIdentifier(node.id, bindingType);
			} else if (optionalId || !isStatement) node.id = null;
			else throw this.raise(Errors.MissingClassName, this.state.startLoc);
		}
		parseClassSuper(node) {
			node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
		}
		parseExport(node, decorators) {
			const maybeDefaultIdentifier = this.parseMaybeImportPhase(node, true);
			const hasDefault = this.maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier);
			const parseAfterDefault = !hasDefault || this.eat(12);
			const hasStar = parseAfterDefault && this.eatExportStar(node);
			const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
			const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));
			const isFromRequired = hasDefault || hasStar;
			if (hasStar && !hasNamespace) {
				if (hasDefault) this.unexpected();
				if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
				this.parseExportFrom(node, true);
				this.sawUnambiguousESM = true;
				return this.finishNode(node, "ExportAllDeclaration");
			}
			const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
			if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) this.unexpected(null, 5);
			if (hasNamespace && parseAfterNamespace) this.unexpected(null, 98);
			let hasDeclaration;
			if (isFromRequired || hasSpecifiers) {
				hasDeclaration = false;
				if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
				this.parseExportFrom(node, isFromRequired);
			} else hasDeclaration = this.maybeParseExportDeclaration(node);
			if (isFromRequired || hasSpecifiers || hasDeclaration) {
				var _node2$declaration;
				const node2 = node;
				this.checkExport(node2, true, false, !!node2.source);
				if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") this.maybeTakeDecorators(decorators, node2.declaration, node2);
				else if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
				this.sawUnambiguousESM = true;
				return this.finishNode(node2, "ExportNamedDeclaration");
			}
			if (this.eat(65)) {
				const node2 = node;
				const decl = this.parseExportDefaultExpression();
				node2.declaration = decl;
				if (decl.type === "ClassDeclaration") this.maybeTakeDecorators(decorators, decl, node2);
				else if (decorators) throw this.raise(Errors.UnsupportedDecoratorExport, node);
				this.checkExport(node2, true, true);
				this.sawUnambiguousESM = true;
				return this.finishNode(node2, "ExportDefaultDeclaration");
			}
			throw this.unexpected(null, 5);
		}
		eatExportStar(node) {
			return this.eat(55);
		}
		maybeParseExportDefaultSpecifier(node, maybeDefaultIdentifier) {
			if (maybeDefaultIdentifier || this.isExportDefaultSpecifier()) {
				this.expectPlugin("exportDefaultFrom", maybeDefaultIdentifier == null ? void 0 : maybeDefaultIdentifier.loc.start);
				const id = maybeDefaultIdentifier || this.parseIdentifier(true);
				const specifier = this.startNodeAtNode(id);
				specifier.exported = id;
				node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
				return true;
			}
			return false;
		}
		maybeParseExportNamespaceSpecifier(node) {
			if (this.isContextual(93)) {
				var _ref;
				(_ref = node).specifiers != null || (_ref.specifiers = []);
				const specifier = this.startNodeAt(this.state.lastTokStartLoc);
				this.next();
				specifier.exported = this.parseModuleExportName();
				node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
				return true;
			}
			return false;
		}
		maybeParseExportNamedSpecifiers(node) {
			if (this.match(5)) {
				const node2 = node;
				if (!node2.specifiers) node2.specifiers = [];
				const isTypeExport = node2.exportKind === "type";
				node2.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
				node2.source = null;
				if (this.hasPlugin("importAssertions")) node2.assertions = [];
				else node2.attributes = [];
				node2.declaration = null;
				return true;
			}
			return false;
		}
		maybeParseExportDeclaration(node) {
			if (this.shouldParseExportDeclaration()) {
				node.specifiers = [];
				node.source = null;
				if (this.hasPlugin("importAssertions")) node.assertions = [];
				else node.attributes = [];
				node.declaration = this.parseExportDeclaration(node);
				return true;
			}
			return false;
		}
		isAsyncFunction() {
			if (!this.isContextual(95)) return false;
			const next = this.nextTokenInLineStart();
			return this.isUnparsedContextual(next, "function");
		}
		parseExportDefaultExpression() {
			const expr = this.startNode();
			if (this.match(68)) {
				this.next();
				return this.parseFunction(expr, 5);
			} else if (this.isAsyncFunction()) {
				this.next();
				this.next();
				return this.parseFunction(expr, 13);
			}
			if (this.match(80)) return this.parseClass(expr, true, true);
			if (this.match(26)) {
				if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);
				return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
			}
			if (this.match(75) || this.match(74) || this.isLet() || this.isUsing() || this.isAwaitUsing()) throw this.raise(Errors.UnsupportedDefaultExport, this.state.startLoc);
			const res = this.parseMaybeAssignAllowIn();
			this.semicolon();
			return res;
		}
		parseExportDeclaration(node) {
			if (this.match(80)) return this.parseClass(this.startNode(), true, false);
			return this.parseStatementListItem();
		}
		isExportDefaultSpecifier() {
			const { type } = this.state;
			if (tokenIsIdentifier(type)) {
				if (type === 95 && !this.state.containsEsc || type === 100) return false;
				if ((type === 130 || type === 129) && !this.state.containsEsc) {
					const next = this.nextTokenStart();
					const nextChar = this.input.charCodeAt(next);
					if (nextChar === 123 || this.chStartsBindingIdentifier(nextChar, next) && !this.input.startsWith("from", next)) {
						this.expectOnePlugin(["flow", "typescript"]);
						return false;
					}
				}
			} else if (!this.match(65)) return false;
			const next = this.nextTokenStart();
			const hasFrom = this.isUnparsedContextual(next, "from");
			if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) return true;
			if (this.match(65) && hasFrom) {
				const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
				return nextAfterFrom === 34 || nextAfterFrom === 39;
			}
			return false;
		}
		parseExportFrom(node, expect) {
			if (this.eatContextual(98)) {
				node.source = this.parseImportSource();
				this.checkExport(node);
				this.maybeParseImportAttributes(node);
				this.checkJSONModuleImport(node);
			} else if (expect) this.unexpected();
			this.semicolon();
		}
		shouldParseExportDeclaration() {
			const { type } = this.state;
			if (type === 26) {
				this.expectOnePlugin(["decorators", "decorators-legacy"]);
				if (this.hasPlugin("decorators")) {
					if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) this.raise(Errors.DecoratorBeforeExport, this.state.startLoc);
					return true;
				}
			}
			if (this.isUsing()) {
				this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
				return true;
			}
			if (this.isAwaitUsing()) {
				this.raise(Errors.UsingDeclarationExport, this.state.startLoc);
				return true;
			}
			return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();
		}
		checkExport(node, checkNames, isDefault, isFrom) {
			if (checkNames) {
				var _node$specifiers;
				if (isDefault) {
					this.checkDuplicateExports(node, "default");
					if (this.hasPlugin("exportDefaultFrom")) {
						var _declaration$extra;
						const declaration = node.declaration;
						if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) this.raise(Errors.ExportDefaultFromAsIdentifier, declaration);
					}
				} else if ((_node$specifiers = node.specifiers) != null && _node$specifiers.length) for (const specifier of node.specifiers) {
					const { exported } = specifier;
					const exportName = exported.type === "Identifier" ? exported.name : exported.value;
					this.checkDuplicateExports(specifier, exportName);
					if (!isFrom && specifier.local) {
						const { local } = specifier;
						if (local.type !== "Identifier") this.raise(Errors.ExportBindingIsString, specifier, {
							localName: local.value,
							exportName
						});
						else {
							this.checkReservedWord(local.name, local.loc.start, true, false);
							this.scope.checkLocalExport(local);
						}
					}
				}
				else if (node.declaration) {
					const decl = node.declaration;
					if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
						const { id } = decl;
						if (!id) throw new Error("Assertion failure");
						this.checkDuplicateExports(node, id.name);
					} else if (decl.type === "VariableDeclaration") for (const declaration of decl.declarations) this.checkDeclaration(declaration.id);
				}
			}
		}
		checkDeclaration(node) {
			if (node.type === "Identifier") this.checkDuplicateExports(node, node.name);
			else if (node.type === "ObjectPattern") for (const prop of node.properties) this.checkDeclaration(prop);
			else if (node.type === "ArrayPattern") {
				for (const elem of node.elements) if (elem) this.checkDeclaration(elem);
			} else if (node.type === "ObjectProperty") this.checkDeclaration(node.value);
			else if (node.type === "RestElement") this.checkDeclaration(node.argument);
			else if (node.type === "AssignmentPattern") this.checkDeclaration(node.left);
		}
		checkDuplicateExports(node, exportName) {
			if (this.exportedIdentifiers.has(exportName)) {
				if (exportName === "default") this.raise(Errors.DuplicateDefaultExport, node);
				else this.raise(Errors.DuplicateExport, node, { exportName });
			}
			this.exportedIdentifiers.add(exportName);
		}
		parseExportSpecifiers(isInTypeExport) {
			const nodes = [];
			let first = true;
			this.expect(5);
			while (!this.eat(8)) {
				if (first) first = false;
				else {
					this.expect(12);
					if (this.eat(8)) break;
				}
				const isMaybeTypeOnly = this.isContextual(130);
				const isString = this.match(134);
				const node = this.startNode();
				node.local = this.parseModuleExportName();
				nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));
			}
			return nodes;
		}
		parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
			if (this.eatContextual(93)) node.exported = this.parseModuleExportName();
			else if (isString) node.exported = this.cloneStringLiteral(node.local);
			else if (!node.exported) node.exported = this.cloneIdentifier(node.local);
			return this.finishNode(node, "ExportSpecifier");
		}
		parseModuleExportName() {
			if (this.match(134)) {
				const result = this.parseStringLiteral(this.state.value);
				const surrogate = loneSurrogate.exec(result.value);
				if (surrogate) this.raise(Errors.ModuleExportNameHasLoneSurrogate, result, { surrogateCharCode: surrogate[0].charCodeAt(0) });
				return result;
			}
			return this.parseIdentifier(true);
		}
		isJSONModuleImport(node) {
			if (node.assertions != null) return node.assertions.some(({ key, value }) => {
				return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type");
			});
			return false;
		}
		checkImportReflection(node) {
			const { specifiers } = node;
			const singleBindingType = specifiers.length === 1 ? specifiers[0].type : null;
			if (node.phase === "source") {
				if (singleBindingType !== "ImportDefaultSpecifier") this.raise(Errors.SourcePhaseImportRequiresDefault, specifiers[0].loc.start);
			} else if (node.phase === "defer") {
				if (singleBindingType !== "ImportNamespaceSpecifier") this.raise(Errors.DeferImportRequiresNamespace, specifiers[0].loc.start);
			} else if (node.module) {
				var _node$assertions;
				if (singleBindingType !== "ImportDefaultSpecifier") this.raise(Errors.ImportReflectionNotBinding, specifiers[0].loc.start);
				if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) this.raise(Errors.ImportReflectionHasAssertion, specifiers[0].loc.start);
			}
		}
		checkJSONModuleImport(node) {
			if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") {
				const { specifiers } = node;
				if (specifiers != null) {
					const nonDefaultNamedSpecifier = specifiers.find((specifier) => {
						let imported;
						if (specifier.type === "ExportSpecifier") imported = specifier.local;
						else if (specifier.type === "ImportSpecifier") imported = specifier.imported;
						if (imported !== void 0) return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
					});
					if (nonDefaultNamedSpecifier !== void 0) this.raise(Errors.ImportJSONBindingNotDefault, nonDefaultNamedSpecifier.loc.start);
				}
			}
		}
		isPotentialImportPhase(isExport) {
			if (isExport) return false;
			return this.isContextual(105) || this.isContextual(97) || this.isContextual(127);
		}
		applyImportPhase(node, isExport, phase, loc) {
			if (isExport) return;
			if (phase === "module") {
				this.expectPlugin("importReflection", loc);
				node.module = true;
			} else if (this.hasPlugin("importReflection")) node.module = false;
			if (phase === "source") {
				this.expectPlugin("sourcePhaseImports", loc);
				node.phase = "source";
			} else if (phase === "defer") {
				this.expectPlugin("deferredImportEvaluation", loc);
				node.phase = "defer";
			} else if (this.hasPlugin("sourcePhaseImports")) node.phase = null;
		}
		parseMaybeImportPhase(node, isExport) {
			if (!this.isPotentialImportPhase(isExport)) {
				this.applyImportPhase(node, isExport, null);
				return null;
			}
			const phaseIdentifier = this.startNode();
			const phaseIdentifierName = this.parseIdentifierName(true);
			const { type } = this.state;
			if (tokenIsKeywordOrIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12) {
				this.applyImportPhase(node, isExport, phaseIdentifierName, phaseIdentifier.loc.start);
				return null;
			} else {
				this.applyImportPhase(node, isExport, null);
				return this.createIdentifier(phaseIdentifier, phaseIdentifierName);
			}
		}
		isPrecedingIdImportPhase(phase) {
			const { type } = this.state;
			return tokenIsIdentifier(type) ? type !== 98 || this.lookaheadCharCode() === 102 : type !== 12;
		}
		parseImport(node) {
			if (this.match(134)) return this.parseImportSourceAndAttributes(node);
			return this.parseImportSpecifiersAndAfter(node, this.parseMaybeImportPhase(node, false));
		}
		parseImportSpecifiersAndAfter(node, maybeDefaultIdentifier) {
			node.specifiers = [];
			const parseNext = !this.maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) || this.eat(12);
			const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
			if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
			this.expectContextual(98);
			return this.parseImportSourceAndAttributes(node);
		}
		parseImportSourceAndAttributes(node) {
			node.specifiers != null || (node.specifiers = []);
			node.source = this.parseImportSource();
			this.maybeParseImportAttributes(node);
			this.checkImportReflection(node);
			this.checkJSONModuleImport(node);
			this.semicolon();
			this.sawUnambiguousESM = true;
			return this.finishNode(node, "ImportDeclaration");
		}
		parseImportSource() {
			if (!this.match(134)) this.unexpected();
			return this.parseExprAtom();
		}
		parseImportSpecifierLocal(node, specifier, type) {
			specifier.local = this.parseIdentifier();
			node.specifiers.push(this.finishImportSpecifier(specifier, type));
		}
		finishImportSpecifier(specifier, type, bindingType = 8201) {
			this.checkLVal(specifier.local, { type }, bindingType);
			return this.finishNode(specifier, type);
		}
		parseImportAttributes() {
			this.expect(5);
			const attrs = [];
			const attrNames = /* @__PURE__ */ new Set();
			do {
				if (this.match(8)) break;
				const node = this.startNode();
				const keyName = this.state.value;
				if (attrNames.has(keyName)) this.raise(Errors.ModuleAttributesWithDuplicateKeys, this.state.startLoc, { key: keyName });
				attrNames.add(keyName);
				if (this.match(134)) node.key = this.parseStringLiteral(keyName);
				else node.key = this.parseIdentifier(true);
				this.expect(14);
				if (!this.match(134)) throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
				node.value = this.parseStringLiteral(this.state.value);
				attrs.push(this.finishNode(node, "ImportAttribute"));
			} while (this.eat(12));
			this.expect(8);
			return attrs;
		}
		parseModuleAttributes() {
			const attrs = [];
			const attributes = /* @__PURE__ */ new Set();
			do {
				const node = this.startNode();
				node.key = this.parseIdentifier(true);
				if (node.key.name !== "type") this.raise(Errors.ModuleAttributeDifferentFromType, node.key);
				if (attributes.has(node.key.name)) this.raise(Errors.ModuleAttributesWithDuplicateKeys, node.key, { key: node.key.name });
				attributes.add(node.key.name);
				this.expect(14);
				if (!this.match(134)) throw this.raise(Errors.ModuleAttributeInvalidValue, this.state.startLoc);
				node.value = this.parseStringLiteral(this.state.value);
				attrs.push(this.finishNode(node, "ImportAttribute"));
			} while (this.eat(12));
			return attrs;
		}
		maybeParseImportAttributes(node) {
			let attributes;
			var useWith = false;
			if (this.match(76)) {
				if (this.hasPrecedingLineBreak() && this.lookaheadCharCode() === 40) return;
				this.next();
				if (this.hasPlugin("moduleAttributes")) {
					attributes = this.parseModuleAttributes();
					this.addExtra(node, "deprecatedWithLegacySyntax", true);
				} else attributes = this.parseImportAttributes();
				useWith = true;
			} else if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
				if (!this.hasPlugin("deprecatedImportAssert") && !this.hasPlugin("importAssertions")) this.raise(Errors.ImportAttributesUseAssert, this.state.startLoc);
				if (!this.hasPlugin("importAssertions")) this.addExtra(node, "deprecatedAssertSyntax", true);
				this.next();
				attributes = this.parseImportAttributes();
			} else attributes = [];
			if (!useWith && this.hasPlugin("importAssertions")) node.assertions = attributes;
			else node.attributes = attributes;
		}
		maybeParseDefaultImportSpecifier(node, maybeDefaultIdentifier) {
			if (maybeDefaultIdentifier) {
				const specifier = this.startNodeAtNode(maybeDefaultIdentifier);
				specifier.local = maybeDefaultIdentifier;
				node.specifiers.push(this.finishImportSpecifier(specifier, "ImportDefaultSpecifier"));
				return true;
			} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
				this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
				return true;
			}
			return false;
		}
		maybeParseStarImportSpecifier(node) {
			if (this.match(55)) {
				const specifier = this.startNode();
				this.next();
				this.expectContextual(93);
				this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier");
				return true;
			}
			return false;
		}
		parseNamedImportSpecifiers(node) {
			let first = true;
			this.expect(5);
			while (!this.eat(8)) {
				if (first) first = false;
				else {
					if (this.eat(14)) throw this.raise(Errors.DestructureNamedImport, this.state.startLoc);
					this.expect(12);
					if (this.eat(8)) break;
				}
				const specifier = this.startNode();
				const importedIsString = this.match(134);
				const isMaybeTypeOnly = this.isContextual(130);
				specifier.imported = this.parseModuleExportName();
				const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, void 0);
				node.specifiers.push(importSpecifier);
			}
		}
		parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
			if (this.eatContextual(93)) specifier.local = this.parseIdentifier();
			else {
				const { imported } = specifier;
				if (importedIsString) throw this.raise(Errors.ImportBindingIsString, specifier, { importName: imported.value });
				this.checkReservedWord(imported.name, specifier.loc.start, true, true);
				if (!specifier.local) specifier.local = this.cloneIdentifier(imported);
			}
			return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
		}
		isThisParam(param) {
			return param.type === "Identifier" && param.name === "this";
		}
	};
	var Parser = class extends StatementParser {
		constructor(options, input, pluginsMap) {
			const normalizedOptions = getOptions(options);
			super(normalizedOptions, input);
			this.options = normalizedOptions;
			this.initializeScopes();
			this.plugins = pluginsMap;
			this.filename = normalizedOptions.sourceFilename;
			this.startIndex = normalizedOptions.startIndex;
			let optionFlags = 0;
			if (normalizedOptions.allowAwaitOutsideFunction) optionFlags |= 1;
			if (normalizedOptions.allowReturnOutsideFunction) optionFlags |= 2;
			if (normalizedOptions.allowImportExportEverywhere) optionFlags |= 8;
			if (normalizedOptions.allowSuperOutsideMethod) optionFlags |= 16;
			if (normalizedOptions.allowUndeclaredExports) optionFlags |= 64;
			if (normalizedOptions.allowNewTargetOutsideFunction) optionFlags |= 4;
			if (normalizedOptions.allowYieldOutsideFunction) optionFlags |= 32;
			if (normalizedOptions.ranges) optionFlags |= 128;
			if (normalizedOptions.tokens) optionFlags |= 256;
			if (normalizedOptions.createImportExpressions) optionFlags |= 512;
			if (normalizedOptions.createParenthesizedExpressions) optionFlags |= 1024;
			if (normalizedOptions.errorRecovery) optionFlags |= 2048;
			if (normalizedOptions.attachComment) optionFlags |= 4096;
			if (normalizedOptions.annexB) optionFlags |= 8192;
			this.optionFlags = optionFlags;
		}
		getScopeHandler() {
			return ScopeHandler;
		}
		parse() {
			this.enterInitialScopes();
			const file = this.startNode();
			const program = this.startNode();
			this.nextToken();
			file.errors = null;
			const result = this.parseTopLevel(file, program);
			result.errors = this.state.errors;
			result.comments.length = this.state.commentsLen;
			return result;
		}
	};
	function parse(input, options) {
		var _options;
		if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
			options = Object.assign({}, options);
			try {
				options.sourceType = "module";
				const parser = getParser(options, input);
				const ast = parser.parse();
				if (parser.sawUnambiguousESM) return ast;
				if (parser.ambiguousScriptDifferentAst) try {
					options.sourceType = "script";
					return getParser(options, input).parse();
				} catch (_unused) {}
				else ast.program.sourceType = "script";
				return ast;
			} catch (moduleError) {
				try {
					options.sourceType = "script";
					return getParser(options, input).parse();
				} catch (_unused2) {}
				throw moduleError;
			}
		} else return getParser(options, input).parse();
	}
	function parseExpression(input, options) {
		const parser = getParser(options, input);
		if (parser.options.strictMode) parser.state.strict = true;
		return parser.getExpression();
	}
	function generateExportedTokenTypes(internalTokenTypes) {
		const tokenTypes = {};
		for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
		return tokenTypes;
	}
	generateExportedTokenTypes(tt);
	function getParser(options, input) {
		let cls = Parser;
		const pluginsMap = /* @__PURE__ */ new Map();
		if (options != null && options.plugins) {
			for (const plugin of options.plugins) {
				let name, opts;
				if (typeof plugin === "string") name = plugin;
				else [name, opts] = plugin;
				if (!pluginsMap.has(name)) pluginsMap.set(name, opts || {});
			}
			validatePlugins(pluginsMap);
			cls = getParserClass(pluginsMap);
		}
		return new cls(options, input, pluginsMap);
	}
	const parserClassCache = /* @__PURE__ */ new Map();
	function getParserClass(pluginsMap) {
		const pluginList = [];
		for (const name of mixinPluginNames) if (pluginsMap.has(name)) pluginList.push(name);
		const key = pluginList.join("|");
		let cls = parserClassCache.get(key);
		if (!cls) {
			cls = Parser;
			for (const plugin of pluginList) cls = mixinPlugins[plugin](cls);
			parserClassCache.set(key, cls);
		}
		return cls;
	}
	exports.parse = parse;
	exports.parseExpression = parseExpression;
}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/asyncToGenerator.js
function asyncGeneratorStep(n, t, e, r, o, a, c) {
	try {
		var i = n[a](c), u = i.value;
	} catch (n) {
		e(n);
		return;
	}
	i.done ? t(u) : Promise.resolve(u).then(r, o);
}
function _asyncToGenerator(n) {
	return function() {
		var t = this, e = arguments;
		return new Promise(function(r, o) {
			var a = n.apply(t, e);
			function _next(n) {
				asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
			}
			function _throw(n) {
				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
			}
			_next(void 0);
		});
	};
}
var init_asyncToGenerator = __esmMin((() => {}));
//#endregion
//#region node_modules/.pnpm/estree-walker@2.0.2/node_modules/estree-walker/dist/esm/estree-walker.js
init_objectSpread2();
var import_lib = require_lib$1();
/** @typedef { import('estree').BaseNode} BaseNode */
/** @typedef {{
skip: () => void;
remove: () => void;
replace: (node: BaseNode) => void;
}} WalkerContext */
var WalkerBase = class {
	constructor() {
		/** @type {boolean} */
		this.should_skip = false;
		/** @type {boolean} */
		this.should_remove = false;
		/** @type {BaseNode | null} */
		this.replacement = null;
		/** @type {WalkerContext} */
		this.context = {
			skip: () => this.should_skip = true,
			remove: () => this.should_remove = true,
			replace: (node) => this.replacement = node
		};
	}
	/**
	*
	* @param {any} parent
	* @param {string} prop
	* @param {number} index
	* @param {BaseNode} node
	*/
	replace(parent, prop, index, node) {
		if (parent) {
			if (index !== null) parent[prop][index] = node;
			else parent[prop] = node;
		}
	}
	/**
	*
	* @param {any} parent
	* @param {string} prop
	* @param {number} index
	*/
	remove(parent, prop, index) {
		if (parent) {
			if (index !== null) parent[prop].splice(index, 1);
			else delete parent[prop];
		}
	}
};
/** @typedef { import('estree').BaseNode} BaseNode */
/** @typedef { import('./walker.js').WalkerContext} WalkerContext */
/** @typedef {(
*    this: WalkerContext,
*    node: BaseNode,
*    parent: BaseNode,
*    key: string,
*    index: number
* ) => void} SyncHandler */
var SyncWalker = class extends WalkerBase {
	/**
	*
	* @param {SyncHandler} enter
	* @param {SyncHandler} leave
	*/
	constructor(enter, leave) {
		super();
		/** @type {SyncHandler} */
		this.enter = enter;
		/** @type {SyncHandler} */
		this.leave = leave;
	}
	/**
	*
	* @param {BaseNode} node
	* @param {BaseNode} parent
	* @param {string} [prop]
	* @param {number} [index]
	* @returns {BaseNode}
	*/
	visit(node, parent, prop, index) {
		if (node) {
			if (this.enter) {
				const _should_skip = this.should_skip;
				const _should_remove = this.should_remove;
				const _replacement = this.replacement;
				this.should_skip = false;
				this.should_remove = false;
				this.replacement = null;
				this.enter.call(this.context, node, parent, prop, index);
				if (this.replacement) {
					node = this.replacement;
					this.replace(parent, prop, index, node);
				}
				if (this.should_remove) this.remove(parent, prop, index);
				const skipped = this.should_skip;
				const removed = this.should_remove;
				this.should_skip = _should_skip;
				this.should_remove = _should_remove;
				this.replacement = _replacement;
				if (skipped) return node;
				if (removed) return null;
			}
			for (const key in node) {
				const value = node[key];
				if (typeof value !== "object") continue;
				else if (Array.isArray(value)) {
					for (let i = 0; i < value.length; i += 1) if (value[i] !== null && typeof value[i].type === "string") {
						if (!this.visit(value[i], node, key, i)) i--;
					}
				} else if (value !== null && typeof value.type === "string") this.visit(value, node, key, null);
			}
			if (this.leave) {
				const _replacement = this.replacement;
				const _should_remove = this.should_remove;
				this.replacement = null;
				this.should_remove = false;
				this.leave.call(this.context, node, parent, prop, index);
				if (this.replacement) {
					node = this.replacement;
					this.replace(parent, prop, index, node);
				}
				if (this.should_remove) this.remove(parent, prop, index);
				const removed = this.should_remove;
				this.replacement = _replacement;
				this.should_remove = _should_remove;
				if (removed) return null;
			}
		}
		return node;
	}
};
/** @typedef { import('estree').BaseNode} BaseNode */
/** @typedef { import('./sync.js').SyncHandler} SyncHandler */
/** @typedef { import('./async.js').AsyncHandler} AsyncHandler */
/**
*
* @param {BaseNode} ast
* @param {{
*   enter?: SyncHandler
*   leave?: SyncHandler
* }} walker
* @returns {BaseNode}
*/
function walk$2(ast, { enter, leave }) {
	return new SyncWalker(enter, leave).visit(ast, null);
}
//#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)) {
	const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root;
	walk$2(root, {
		enter(node, parent) {
			parent && parentStack.push(parent);
			if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) return this.skip();
			if (node.type === "Identifier") {
				const isLocal = !!knownIds[node.name];
				const isRefed = isReferencedIdentifier(node, parent, parentStack);
				if (includeAll || isRefed && !isLocal) onIdentifier(node, parent, parentStack, isRefed, isLocal);
			} else if (node.type === "ObjectProperty" && (parent === null || parent === void 0 ? void 0 : parent.type) === "ObjectPattern") node.inPattern = true;
			else if (isFunctionType(node)) {
				if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
				else walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
			} else if (node.type === "BlockStatement") {
				if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
				else walkBlockDeclarations(node, (id) => markScopeIdentifier(node, id, knownIds));
			} else if (node.type === "SwitchStatement") {
				if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
				else walkSwitchStatement(node, false, (id) => markScopeIdentifier(node, id, knownIds));
			} else if (node.type === "CatchClause" && node.param) {
				if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
				else for (const id of extractIdentifiers(node.param)) markScopeIdentifier(node, id, knownIds);
			} else if (isForStatement(node)) {
				if (node.scopeIds) node.scopeIds.forEach((id) => markKnownIds(id, knownIds));
				else walkForStatement(node, false, (id) => markScopeIdentifier(node, id, knownIds));
			}
		},
		leave(node, parent) {
			parent && parentStack.pop();
			if (node !== rootExp && node.scopeIds) for (const id of node.scopeIds) {
				knownIds[id]--;
				if (knownIds[id] === 0) delete knownIds[id];
			}
		}
	});
}
function isReferencedIdentifier(id, parent, parentStack) {
	if (!parent) return true;
	if (id.name === "arguments") return false;
	if (isReferenced(id, parent, parentStack[parentStack.length - 2])) return true;
	switch (parent.type) {
		case "AssignmentExpression":
		case "AssignmentPattern": return true;
		case "ObjectProperty": return parent.key !== id && isInDestructureAssignment(parent, parentStack);
		case "ArrayPattern": return isInDestructureAssignment(parent, parentStack);
	}
	return false;
}
function isInDestructureAssignment(parent, parentStack) {
	if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
		let i = parentStack.length;
		while (i--) {
			const p = parentStack[i];
			if (p.type === "AssignmentExpression") return true;
			else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) break;
		}
	}
	return false;
}
function isInNewExpression(parentStack) {
	let i = parentStack.length;
	while (i--) {
		const p = parentStack[i];
		if (p.type === "NewExpression") return true;
		else if (p.type !== "MemberExpression") break;
	}
	return false;
}
function walkFunctionParams(node, onIdent) {
	for (const p of node.params) for (const id of extractIdentifiers(p)) onIdent(id);
}
function walkBlockDeclarations(block, onIdent) {
	const body = block.type === "SwitchCase" ? block.consequent : block.body;
	for (const stmt of body) if (stmt.type === "VariableDeclaration") {
		if (stmt.declare) continue;
		for (const decl of stmt.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
	} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
		if (stmt.declare || !stmt.id) continue;
		onIdent(stmt.id);
	} else if (isForStatement(stmt)) walkForStatement(stmt, true, onIdent);
	else if (stmt.type === "SwitchStatement") walkSwitchStatement(stmt, true, onIdent);
}
function isForStatement(stmt) {
	return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
}
function walkForStatement(stmt, isVar, onIdent) {
	const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
	if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) for (const decl of variable.declarations) for (const id of extractIdentifiers(decl.id)) onIdent(id);
}
function walkSwitchStatement(stmt, isVar, onIdent) {
	for (const cs of stmt.cases) {
		for (const 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;
}
function markKnownIds(name, knownIds) {
	if (name in knownIds) knownIds[name]++;
	else knownIds[name] = 1;
}
function markScopeIdentifier(node, child, knownIds) {
	const { name } = child;
	if (node.scopeIds && node.scopeIds.has(name)) return;
	markKnownIds(name, knownIds);
	(node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
}
const isFunctionType = (node) => {
	return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
};
const isStaticProperty = (node) => !!node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
/**
* Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts
* To avoid runtime dependency on @babel/types (which includes process references)
* This file should not change very often in babel but we may need to keep it
* up-to-date from time to time.
*
* https://github.com/babel/babel/blob/main/LICENSE
*
*/
function isReferenced(node, parent, grandparent) {
	switch (parent.type) {
		case "MemberExpression":
		case "OptionalMemberExpression":
			if (parent.property === node) return !!parent.computed;
			return parent.object === node;
		case "JSXMemberExpression": return parent.object === node;
		case "VariableDeclarator": return parent.init === node;
		case "ArrowFunctionExpression": return parent.body === node;
		case "PrivateName": return false;
		case "ClassMethod":
		case "ClassPrivateMethod":
		case "ObjectMethod":
			if (parent.key === node) return !!parent.computed;
			return false;
		case "ObjectProperty":
			if (parent.key === node) return !!parent.computed;
			return !grandparent || grandparent.type !== "ObjectPattern";
		case "ClassProperty":
			if (parent.key === node) return !!parent.computed;
			return true;
		case "ClassPrivateProperty": return parent.key !== node;
		case "ClassDeclaration":
		case "ClassExpression": return parent.superClass === node;
		case "AssignmentExpression": return parent.right === node;
		case "AssignmentPattern": return parent.right === node;
		case "LabeledStatement": return false;
		case "CatchClause": return false;
		case "RestElement": return false;
		case "BreakStatement":
		case "ContinueStatement": return false;
		case "FunctionDeclaration":
		case "FunctionExpression": return false;
		case "ExportNamespaceSpecifier":
		case "ExportDefaultSpecifier": return false;
		case "ExportSpecifier":
			if (grandparent === null || grandparent === void 0 ? void 0 : grandparent.source) return false;
			return parent.local === node;
		case "ImportDefaultSpecifier":
		case "ImportNamespaceSpecifier":
		case "ImportSpecifier": return false;
		case "ImportAttribute": return false;
		case "JSXAttribute": return false;
		case "ObjectPattern":
		case "ArrayPattern": return false;
		case "MetaProperty": return false;
		case "ObjectTypeProperty": return parent.key !== node;
		case "TSEnumMember": return parent.id !== node;
		case "TSPropertySignature":
			if (parent.key === node) return !!parent.computed;
			return true;
	}
	return true;
}
const TS_NODE_TYPES = [
	"TSAsExpression",
	"TSTypeAssertion",
	"TSNonNullExpression",
	"TSInstantiationExpression",
	"TSSatisfiesExpression"
];
function unwrapTSNode(node) {
	if (TS_NODE_TYPES.includes(node.type)) return unwrapTSNode(node.expression);
	else return node;
}
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 = (exp, context) => {
	try {
		let ret = exp.ast || (0, import_lib.parseExpression)(getExpSource(exp), { plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] });
		ret = unwrapTSNode(ret);
		return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined";
	} catch (e) {
		return false;
	}
};
const isMemberExpression$1 = isMemberExpressionNode;
const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/;
const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
const isFnExpressionNode = (exp, context) => {
	try {
		let ret = exp.ast || (0, import_lib.parseExpression)(getExpSource(exp), { plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"] });
		if (ret.type === "Program") {
			ret = ret.body[0];
			if (ret.type === "ExpressionStatement") ret = ret.expression;
		}
		ret = unwrapTSNode(ret);
		return ret.type === "FunctionExpression" || ret.type === "ArrowFunctionExpression";
	} catch (e) {
		return false;
	}
};
const isFnExpression = isFnExpressionNode;
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
	return advancePositionWithMutation({
		offset: pos.offset,
		line: pos.line,
		column: pos.column
	}, source, numberOfCharacters);
}
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
	let linesCount = 0;
	let lastNewLinePos = -1;
	for (let i = 0; i < numberOfCharacters; i++) if (source.charCodeAt(i) === 10) {
		linesCount++;
		lastNewLinePos = i;
	}
	pos.offset += numberOfCharacters;
	pos.line += linesCount;
	pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
	return pos;
}
function assert(condition, msg) {
	/* v8 ignore next 3 */
	if (!condition) throw new Error(msg || `unexpected compiler condition`);
}
/** find directive */
function findDir$1(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$1(name) ? p.name === name : name.test(p.name))) return p;
	}
}
function findProp$1(node, name, dynamicOnly = false, allowEmpty = false) {
	for (let i = 0; i < node.props.length; i++) {
		const p = node.props[i];
		if (p.type === 6) {
			if (dynamicOnly) continue;
			if (p.name === name && (p.value || allowEmpty)) return p;
		} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) return p;
	}
}
function isStaticArgOf(arg, name) {
	return !!(arg && isStaticExp(arg) && arg.content === name);
}
function hasDynamicKeyVBind(node) {
	return node.props.some((p) => p.type === 7 && p.name === "bind" && (!p.arg || p.arg.type !== 4 || !p.arg.isStatic));
}
function isText$1(node) {
	return node.type === 5 || node.type === 2;
}
function isVPre(p) {
	return p.type === 7 && p.name === "pre";
}
function isVSlot(p) {
	return p.type === 7 && p.name === "slot";
}
function isTemplateNode(node) {
	return node.type === 1 && node.tagType === 3;
}
function isSlotOutlet(node) {
	return node.type === 1 && node.tagType === 2;
}
const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
function getUnnormalizedProps(props, callPath = []) {
	if (props && !isString$1(props) && props.type === 14) {
		const callee = props.callee;
		if (!isString$1(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$1(props) && props.type === 14) {
		const ret = getUnnormalizedProps(props);
		props = ret[0];
		callPath = ret[1];
		parentCall = callPath[callPath.length - 1];
	}
	if (props == null || isString$1(props)) propsWithInjection = createObjectExpression([prop]);
	else if (props.type === 14) {
		const first = props.arguments[0];
		if (!isString$1(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$1(props)) {
		const [unnormalizedProps] = getUnnormalizedProps(props);
		if (unnormalizedProps && !isString$1(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$2(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$1(c, "if")) {
		if (hasEncounteredIf) return false;
		hasEncounteredIf = true;
	} else if (!hasEncounteredIf || !(c.type === 1 && findDir$1(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$1(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$1(currentInput.charCodeAt(innerStart))) innerStart++;
		while (isWhitespace$1(currentInput.charCodeAt(innerEnd - 1))) innerEnd--;
		let exp = getSlice(innerStart, innerEnd);
		if (exp.includes("&")) exp = decodeHTML(exp);
		addNode({
			type: 5,
			content: createExp(exp, false, getLoc(innerStart, innerEnd)),
			loc: getLoc(start, end)
		});
	},
	onopentagname(start, end) {
		const name = getSlice(start, end);
		currentOpenTag = {
			type: 1,
			tag: name,
			ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
			tagType: 0,
			props: [],
			children: [],
			loc: getLoc(start - 1, end),
			codegenNode: void 0
		};
	},
	onopentagend(end) {
		endOpenTag(end);
	},
	onclosetag(start, end) {
		const name = getSlice(start, end);
		if (!currentOptions.isVoidTag(name)) {
			let found = false;
			for (let i = 0; i < stack.length; i++) if (stack[i].tag.toLowerCase() === name.toLowerCase()) {
				found = true;
				if (i > 0) emitError(24, stack[0].loc.start.offset);
				for (let j = 0; j <= i; j++) onCloseTag(stack.shift(), end, j < i);
				break;
			}
			if (!found) emitError(23, backTrack(start, 60));
		}
	},
	onselfclosingtag(end) {
		const name = currentOpenTag.tag;
		currentOpenTag.isSelfClosing = true;
		endOpenTag(end);
		if (stack[0] && stack[0].tag === name) onCloseTag(stack.shift(), end);
	},
	onattribname(start, end) {
		currentProp = {
			type: 6,
			name: getSlice(start, end),
			nameLoc: getLoc(start, end),
			value: void 0,
			loc: getLoc(start)
		};
	},
	ondirname(start, end) {
		const raw = getSlice(start, end);
		const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
		if (!inVPre && name === "") emitError(26, start);
		if (inVPre || name === "") currentProp = {
			type: 6,
			name: raw,
			nameLoc: getLoc(start, end),
			value: void 0,
			loc: getLoc(start)
		};
		else {
			currentProp = {
				type: 7,
				name,
				rawName: raw,
				exp: void 0,
				arg: void 0,
				modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
				loc: getLoc(start)
			};
			if (name === "pre") {
				inVPre = tokenizer.inVPre = true;
				currentVPreBoundary = currentOpenTag;
				const props = currentOpenTag.props;
				for (let i = 0; i < props.length; i++) if (props[i].type === 7) props[i] = dirToAttr(props[i]);
			}
		}
	},
	ondirarg(start, end) {
		if (start === end) return;
		const arg = getSlice(start, end);
		if (inVPre && !isVPre(currentProp)) {
			currentProp.name += arg;
			setLocEnd(currentProp.nameLoc, end);
		} else {
			const isStatic = arg[0] !== `[`;
			currentProp.arg = createExp(isStatic ? arg : arg.slice(1, -1), isStatic, getLoc(start, end), isStatic ? 3 : 0);
		}
	},
	ondirmodifier(start, end) {
		const mod = getSlice(start, end);
		if (inVPre && !isVPre(currentProp)) {
			currentProp.name += "." + mod;
			setLocEnd(currentProp.nameLoc, end);
		} else if (currentProp.name === "slot") {
			const arg = currentProp.arg;
			if (arg) {
				arg.content += "." + mod;
				setLocEnd(arg.loc, end);
			}
		} else {
			const exp = createSimpleExpression(mod, true, getLoc(start, end));
			currentProp.modifiers.push(exp);
		}
	},
	onattribdata(start, end) {
		currentAttrValue += getSlice(start, end);
		if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
		currentAttrEndIndex = end;
	},
	onattribentity(char, start, end) {
		currentAttrValue += char;
		if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
		currentAttrEndIndex = end;
	},
	onattribnameend(end) {
		const start = currentProp.loc.start.offset;
		const name = getSlice(start, end);
		if (currentProp.type === 7) currentProp.rawName = name;
		if (currentOpenTag.props.some((p) => (p.type === 7 ? p.rawName : p.name) === name)) emitError(2, start);
	},
	onattribend(quote, end) {
		if (currentOpenTag && currentProp) {
			setLocEnd(currentProp.loc, end);
			if (quote !== 0) {
				if (currentProp.type === 6) {
					if (currentProp.name === "class") currentAttrValue = condense(currentAttrValue).trim();
					if (quote === 1 && !currentAttrValue) emitError(13, end);
					currentProp.value = {
						type: 2,
						content: currentAttrValue,
						loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
					};
					if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
				} else {
					let expParseMode = 0;
					if (currentProp.name === "for") expParseMode = 3;
					else if (currentProp.name === "slot") expParseMode = 1;
					else if (currentProp.name === "on" && currentAttrValue.includes(";")) expParseMode = 2;
					currentProp.exp = createExp(currentAttrValue, false, getLoc(currentAttrStartIndex, currentAttrEndIndex), 0, expParseMode);
					if (currentProp.name === "for") currentProp.forParseResult = parseForExpression(currentProp.exp);
				}
			}
			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 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;
}
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;
			}
		}
	}
	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$1(str.charCodeAt(i))) {
		if (!prevCharIsWhitespace) {
			ret += " ";
			prevCharIsWhitespace = true;
		}
	} else {
		ret += str[i];
		prevCharIsWhitespace = false;
	}
	return ret;
}
function addNode(node) {
	(stack[0] || currentRoot).children.push(node);
}
function getLoc(start, end) {
	return {
		start: tokenizer.getPos(start),
		end: end == null ? end : tokenizer.getPos(end),
		source: end == null ? end : getSlice(start, end)
	};
}
function cloneLoc(loc) {
	return getLoc(loc.start.offset, loc.end.offset);
}
function setLocEnd(loc, end) {
	loc.end = tokenizer.getPos(end);
	loc.source = getSlice(loc.start.offset, end);
}
function dirToAttr(dir) {
	const attr = {
		type: 6,
		name: dir.rawName,
		nameLoc: getLoc(dir.loc.start.offset, dir.loc.start.offset + dir.rawName.length),
		value: void 0,
		loc: dir.loc
	};
	if (dir.exp) {
		const loc = dir.exp.loc;
		if (loc.end.offset < dir.loc.end.offset) {
			loc.start.offset--;
			loc.start.column--;
			loc.end.offset++;
			loc.end.column++;
		}
		attr.value = {
			type: 2,
			content: dir.exp.content,
			loc
		};
	}
	return attr;
}
function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0) {
	const exp = createSimpleExpression(content, isStatic, loc, constType);
	if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 && content.trim()) {
		if (isSimpleIdentifier(content)) {
			exp.ast = null;
			return exp;
		}
		try {
			const plugins = currentOptions.expressionPlugins;
			const options = { plugins: plugins ? [...plugins, "typescript"] : ["typescript"] };
			if (parseMode === 2) exp.ast = (0, import_lib.parse)(` ${content} `, options).program;
			else if (parseMode === 1) exp.ast = (0, import_lib.parseExpression)(`(${content})=>{}`, options);
			else exp.ast = (0, import_lib.parseExpression)(`(${content})`, options);
		} catch (e) {
			exp.ast = false;
			emitError(46, loc.start.offset, e.message);
		}
	}
	return exp;
}
function emitError(code, index, message) {
	currentOptions.onError(createCompilerError(code, getLoc(index, index), void 0, message));
}
function reset() {
	tokenizer.reset();
	currentOpenTag = null;
	currentProp = null;
	currentAttrValue = "";
	currentAttrStartIndex = -1;
	currentAttrEndIndex = -1;
	stack.length = 0;
}
function baseParse(input, options) {
	reset();
	currentInput = input;
	currentOptions = extend({}, defaultParserOptions);
	if (options) {
		let key;
		for (key in options) if (options[key] != null) currentOptions[key] = options[key];
	}
	if (currentOptions.decodeEntities) console.warn("[@vue/compiler-core] decodeEntities option is passed but will be ignored in non-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$1(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$1(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$1(child, node, context, false, inFor);
			if (isComponent) context.scopes.vSlot--;
		} else if (child.type === 11) walk$1(child, node, context, child.children.length === 1, true);
		else if (child.type === 9) for (let i = 0; i < child.branches.length; i++) walk$1(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$3(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$3(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$3(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
			const slotName = findDir$1(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$3(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$1(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$1(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") {
			if (isString$1(exp)) addId(exp, type);
			else if (exp.identifiers) exp.identifiers.forEach((id) => addId(id, type));
			else if (exp.type === 4) addId(exp.content, type);
		},
		removeIdentifiers(exp) {
			if (isString$1(exp)) removeId(exp);
			else if (exp.identifiers) exp.identifiers.forEach(removeId);
			else if (exp.type === 4) removeId(exp.content);
		},
		isSlotScopeIdentifier(name) {
			const scopes = context.identifierScopes[name];
			return scopes ? scopes[scopes.length - 1] === "slot" : false;
		},
		hoist(exp) {
			if (isString$1(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;
		}
	};
	function addId(id, type) {
		const { identifiers, identifierScopes } = context;
		if (identifiers[id] === void 0) identifiers[id] = 0;
		identifiers[id]++;
		(identifierScopes[id] || (identifierScopes[id] = [])).push(type);
	}
	function removeId(id) {
		context.identifiers[id]--;
		const scopes = context.identifierScopes[id];
		if (scopes) scopes.pop();
	}
	return context;
}
function transform$1(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;
}
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$1(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$3(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$1(name, fn) {
	const matches = isString$1(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 node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/base64.js
var require_base64$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
	/**
	* Encode an integer in the range of 0 to 63 to a single base 64 digit.
	*/
	exports.encode = function(number) {
		if (0 <= number && number < intToCharMap.length) return intToCharMap[number];
		throw new TypeError("Must be between 0 and 63: " + number);
	};
	/**
	* Decode a single base 64 character code digit to an integer. Returns -1 on
	* failure.
	*/
	exports.decode = function(charCode) {
		var bigA = 65;
		var bigZ = 90;
		var littleA = 97;
		var littleZ = 122;
		var zero = 48;
		var nine = 57;
		var plus = 43;
		var slash = 47;
		var littleOffset = 26;
		var numberOffset = 52;
		if (bigA <= charCode && charCode <= bigZ) return charCode - bigA;
		if (littleA <= charCode && charCode <= littleZ) return charCode - littleA + littleOffset;
		if (zero <= charCode && charCode <= nine) return charCode - zero + numberOffset;
		if (charCode == plus) return 62;
		if (charCode == slash) return 63;
		return -1;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/base64-vlq.js
var require_base64_vlq$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var base64 = require_base64$1();
	var VLQ_BASE_SHIFT = 5;
	var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
	var VLQ_BASE_MASK = VLQ_BASE - 1;
	var VLQ_CONTINUATION_BIT = VLQ_BASE;
	/**
	* Converts from a two-complement value to a value where the sign bit is
	* placed in the least significant bit.  For example, as decimals:
	*   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
	*   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
	*/
	function toVLQSigned(aValue) {
		return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
	}
	/**
	* Converts to a two-complement value from a value where the sign bit is
	* placed in the least significant bit.  For example, as decimals:
	*   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
	*   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
	*/
	function fromVLQSigned(aValue) {
		var isNegative = (aValue & 1) === 1;
		var shifted = aValue >> 1;
		return isNegative ? -shifted : shifted;
	}
	/**
	* Returns the base 64 VLQ encoded value.
	*/
	exports.encode = function base64VLQ_encode(aValue) {
		var encoded = "";
		var digit;
		var vlq = toVLQSigned(aValue);
		do {
			digit = vlq & VLQ_BASE_MASK;
			vlq >>>= VLQ_BASE_SHIFT;
			if (vlq > 0) digit |= VLQ_CONTINUATION_BIT;
			encoded += base64.encode(digit);
		} while (vlq > 0);
		return encoded;
	};
	/**
	* Decodes the next base 64 VLQ value from the given string and returns the
	* value and the rest of the string via the out parameter.
	*/
	exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
		var strLen = aStr.length;
		var result = 0;
		var shift = 0;
		var continuation, digit;
		do {
			if (aIndex >= strLen) throw new Error("Expected more digits in base 64 VLQ value.");
			digit = base64.decode(aStr.charCodeAt(aIndex++));
			if (digit === -1) throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
			continuation = !!(digit & VLQ_CONTINUATION_BIT);
			digit &= VLQ_BASE_MASK;
			result = result + (digit << shift);
			shift += VLQ_BASE_SHIFT;
		} while (continuation);
		aOutParam.value = fromVLQSigned(result);
		aOutParam.rest = aIndex;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/util.js
var require_util$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
	/**
	* This is a helper function for getting values from parameter/options
	* objects.
	*
	* @param args The object we are extracting values from
	* @param name The name of the property we are getting.
	* @param defaultValue An optional value to return if the property is missing
	* from the object. If this is not specified and the property is missing, an
	* error will be thrown.
	*/
	function getArg(aArgs, aName, aDefaultValue) {
		if (aName in aArgs) return aArgs[aName];
		else if (arguments.length === 3) return aDefaultValue;
		else throw new Error("\"" + aName + "\" is a required argument.");
	}
	exports.getArg = getArg;
	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
	var dataUrlRegexp = /^data:.+\,.+$/;
	function urlParse(aUrl) {
		var match = aUrl.match(urlRegexp);
		if (!match) return null;
		return {
			scheme: match[1],
			auth: match[2],
			host: match[3],
			port: match[4],
			path: match[5]
		};
	}
	exports.urlParse = urlParse;
	function urlGenerate(aParsedUrl) {
		var url = "";
		if (aParsedUrl.scheme) url += aParsedUrl.scheme + ":";
		url += "//";
		if (aParsedUrl.auth) url += aParsedUrl.auth + "@";
		if (aParsedUrl.host) url += aParsedUrl.host;
		if (aParsedUrl.port) url += ":" + aParsedUrl.port;
		if (aParsedUrl.path) url += aParsedUrl.path;
		return url;
	}
	exports.urlGenerate = urlGenerate;
	var MAX_CACHED_INPUTS = 32;
	/**
	* Takes some function `f(input) -> result` and returns a memoized version of
	* `f`.
	*
	* We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
	* memoization is a dumb-simple, linear least-recently-used cache.
	*/
	function lruMemoize(f) {
		var cache = [];
		return function(input) {
			for (var i = 0; i < cache.length; i++) if (cache[i].input === input) {
				var temp = cache[0];
				cache[0] = cache[i];
				cache[i] = temp;
				return cache[0].result;
			}
			var result = f(input);
			cache.unshift({
				input,
				result
			});
			if (cache.length > MAX_CACHED_INPUTS) cache.pop();
			return result;
		};
	}
	/**
	* Normalizes a path, or the path portion of a URL:
	*
	* - Replaces consecutive slashes with one slash.
	* - Removes unnecessary '.' parts.
	* - Removes unnecessary '<dir>/..' parts.
	*
	* Based on code in the Node.js 'path' core module.
	*
	* @param aPath The path or url to normalize.
	*/
	var normalize = lruMemoize(function normalize(aPath) {
		var path = aPath;
		var url = urlParse(aPath);
		if (url) {
			if (!url.path) return aPath;
			path = url.path;
		}
		var isAbsolute = exports.isAbsolute(path);
		var parts = [];
		var start = 0;
		var i = 0;
		while (true) {
			start = i;
			i = path.indexOf("/", start);
			if (i === -1) {
				parts.push(path.slice(start));
				break;
			} else {
				parts.push(path.slice(start, i));
				while (i < path.length && path[i] === "/") i++;
			}
		}
		for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
			part = parts[i];
			if (part === ".") parts.splice(i, 1);
			else if (part === "..") up++;
			else if (up > 0) {
				if (part === "") {
					parts.splice(i + 1, up);
					up = 0;
				} else {
					parts.splice(i, 2);
					up--;
				}
			}
		}
		path = parts.join("/");
		if (path === "") path = isAbsolute ? "/" : ".";
		if (url) {
			url.path = path;
			return urlGenerate(url);
		}
		return path;
	});
	exports.normalize = normalize;
	/**
	* Joins two paths/URLs.
	*
	* @param aRoot The root path or URL.
	* @param aPath The path or URL to be joined with the root.
	*
	* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
	*   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
	*   first.
	* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
	*   is updated with the result and aRoot is returned. Otherwise the result
	*   is returned.
	*   - If aPath is absolute, the result is aPath.
	*   - Otherwise the two paths are joined with a slash.
	* - Joining for example 'http://' and 'www.example.com' is also supported.
	*/
	function join(aRoot, aPath) {
		if (aRoot === "") aRoot = ".";
		if (aPath === "") aPath = ".";
		var aPathUrl = urlParse(aPath);
		var aRootUrl = urlParse(aRoot);
		if (aRootUrl) aRoot = aRootUrl.path || "/";
		if (aPathUrl && !aPathUrl.scheme) {
			if (aRootUrl) aPathUrl.scheme = aRootUrl.scheme;
			return urlGenerate(aPathUrl);
		}
		if (aPathUrl || aPath.match(dataUrlRegexp)) return aPath;
		if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
			aRootUrl.host = aPath;
			return urlGenerate(aRootUrl);
		}
		var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
		if (aRootUrl) {
			aRootUrl.path = joined;
			return urlGenerate(aRootUrl);
		}
		return joined;
	}
	exports.join = join;
	exports.isAbsolute = function(aPath) {
		return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
	};
	/**
	* Make a path relative to a URL or another path.
	*
	* @param aRoot The root path or URL.
	* @param aPath The path or URL to be made relative to aRoot.
	*/
	function relative(aRoot, aPath) {
		if (aRoot === "") aRoot = ".";
		aRoot = aRoot.replace(/\/$/, "");
		var level = 0;
		while (aPath.indexOf(aRoot + "/") !== 0) {
			var index = aRoot.lastIndexOf("/");
			if (index < 0) return aPath;
			aRoot = aRoot.slice(0, index);
			if (aRoot.match(/^([^\/]+:\/)?\/*$/)) return aPath;
			++level;
		}
		return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
	}
	exports.relative = relative;
	var supportsNullProto = function() {
		return !("__proto__" in Object.create(null));
	}();
	function identity(s) {
		return s;
	}
	/**
	* Because behavior goes wacky when you set `__proto__` on objects, we
	* have to prefix all the strings in our set with an arbitrary character.
	*
	* See https://github.com/mozilla/source-map/pull/31 and
	* https://github.com/mozilla/source-map/issues/30
	*
	* @param String aStr
	*/
	function toSetString(aStr) {
		if (isProtoString(aStr)) return "$" + aStr;
		return aStr;
	}
	exports.toSetString = supportsNullProto ? identity : toSetString;
	function fromSetString(aStr) {
		if (isProtoString(aStr)) return aStr.slice(1);
		return aStr;
	}
	exports.fromSetString = supportsNullProto ? identity : fromSetString;
	function isProtoString(s) {
		if (!s) return false;
		var length = s.length;
		if (length < 9) return false;
		if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) return false;
		for (var i = length - 10; i >= 0; i--) if (s.charCodeAt(i) !== 36) return false;
		return true;
	}
	/**
	* Comparator between two mappings where the original positions are compared.
	*
	* Optionally pass in `true` as `onlyCompareGenerated` to consider two
	* mappings with the same original source/line/column, but different generated
	* line and column the same. Useful when searching for a mapping with a
	* stubbed out mapping.
	*/
	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
		var cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0 || onlyCompareOriginal) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByOriginalPositions = compareByOriginalPositions;
	function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
		var cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0 || onlyCompareOriginal) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
	/**
	* Comparator between two mappings with deflated source and name indices where
	* the generated positions are compared.
	*
	* Optionally pass in `true` as `onlyCompareGenerated` to consider two
	* mappings with the same generated line and column, but different
	* source/name/original line and column the same. Useful when searching for a
	* mapping with a stubbed out mapping.
	*/
	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
		var cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0 || onlyCompareGenerated) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
	function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
		var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0 || onlyCompareGenerated) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
	function strcmp(aStr1, aStr2) {
		if (aStr1 === aStr2) return 0;
		if (aStr1 === null) return 1;
		if (aStr2 === null) return -1;
		if (aStr1 > aStr2) return 1;
		return -1;
	}
	/**
	* Comparator between two mappings with inflated source and name strings where
	* the generated positions are compared.
	*/
	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
		var cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
	/**
	* Strip any JSON XSSI avoidance prefix from the string (as documented
	* in the source maps specification), and then parse the string as
	* JSON.
	*/
	function parseSourceMapInput(str) {
		return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
	}
	exports.parseSourceMapInput = parseSourceMapInput;
	/**
	* Compute the URL of a source given the the source root, the source's
	* URL, and the source map's URL.
	*/
	function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
		sourceURL = sourceURL || "";
		if (sourceRoot) {
			if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") sourceRoot += "/";
			sourceURL = sourceRoot + sourceURL;
		}
		if (sourceMapURL) {
			var parsed = urlParse(sourceMapURL);
			if (!parsed) throw new Error("sourceMapURL could not be parsed");
			if (parsed.path) {
				var index = parsed.path.lastIndexOf("/");
				if (index >= 0) parsed.path = parsed.path.substring(0, index + 1);
			}
			sourceURL = join(urlGenerate(parsed), sourceURL);
		}
		return normalize(sourceURL);
	}
	exports.computeSourceURL = computeSourceURL;
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/array-set.js
var require_array_set$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util$2();
	var has = Object.prototype.hasOwnProperty;
	var hasNativeMap = typeof Map !== "undefined";
	/**
	* A data structure which is a combination of an array and a set. Adding a new
	* member is O(1), testing for membership is O(1), and finding the index of an
	* element is O(1). Removing elements from the set is not supported. Only
	* strings are supported for membership.
	*/
	function ArraySet() {
		this._array = [];
		this._set = hasNativeMap ? /* @__PURE__ */ new Map() : Object.create(null);
	}
	/**
	* Static method for creating ArraySet instances from an existing array.
	*/
	ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
		var set = new ArraySet();
		for (var i = 0, len = aArray.length; i < len; i++) set.add(aArray[i], aAllowDuplicates);
		return set;
	};
	/**
	* Return how many unique items are in this ArraySet. If duplicates have been
	* added, than those do not count towards the size.
	*
	* @returns Number
	*/
	ArraySet.prototype.size = function ArraySet_size() {
		return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
	};
	/**
	* Add the given string to this set.
	*
	* @param String aStr
	*/
	ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
		var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
		var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
		var idx = this._array.length;
		if (!isDuplicate || aAllowDuplicates) this._array.push(aStr);
		if (!isDuplicate) {
			if (hasNativeMap) this._set.set(aStr, idx);
			else this._set[sStr] = idx;
		}
	};
	/**
	* Is the given string a member of this set?
	*
	* @param String aStr
	*/
	ArraySet.prototype.has = function ArraySet_has(aStr) {
		if (hasNativeMap) return this._set.has(aStr);
		else {
			var sStr = util.toSetString(aStr);
			return has.call(this._set, sStr);
		}
	};
	/**
	* What is the index of the given string in the array?
	*
	* @param String aStr
	*/
	ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
		if (hasNativeMap) {
			var idx = this._set.get(aStr);
			if (idx >= 0) return idx;
		} else {
			var sStr = util.toSetString(aStr);
			if (has.call(this._set, sStr)) return this._set[sStr];
		}
		throw new Error("\"" + aStr + "\" is not in the set.");
	};
	/**
	* What is the element at the given index?
	*
	* @param Number aIdx
	*/
	ArraySet.prototype.at = function ArraySet_at(aIdx) {
		if (aIdx >= 0 && aIdx < this._array.length) return this._array[aIdx];
		throw new Error("No element indexed by " + aIdx);
	};
	/**
	* Returns the array representation of this set (which has the proper indices
	* indicated by indexOf). Note that this is a copy of the internal array used
	* for storing the members so that no one can mess with internal state.
	*/
	ArraySet.prototype.toArray = function ArraySet_toArray() {
		return this._array.slice();
	};
	exports.ArraySet = ArraySet;
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/mapping-list.js
var require_mapping_list$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util$2();
	/**
	* Determine whether mappingB is after mappingA with respect to generated
	* position.
	*/
	function generatedPositionAfter(mappingA, mappingB) {
		var lineA = mappingA.generatedLine;
		var lineB = mappingB.generatedLine;
		var columnA = mappingA.generatedColumn;
		var columnB = mappingB.generatedColumn;
		return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
	}
	/**
	* A data structure to provide a sorted view of accumulated mappings in a
	* performance conscious manner. It trades a neglibable overhead in general
	* case for a large speedup in case of mappings being added in order.
	*/
	function MappingList() {
		this._array = [];
		this._sorted = true;
		this._last = {
			generatedLine: -1,
			generatedColumn: 0
		};
	}
	/**
	* Iterate through internal items. This method takes the same arguments that
	* `Array.prototype.forEach` takes.
	*
	* NOTE: The order of the mappings is NOT guaranteed.
	*/
	MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
		this._array.forEach(aCallback, aThisArg);
	};
	/**
	* Add the given source mapping.
	*
	* @param Object aMapping
	*/
	MappingList.prototype.add = function MappingList_add(aMapping) {
		if (generatedPositionAfter(this._last, aMapping)) {
			this._last = aMapping;
			this._array.push(aMapping);
		} else {
			this._sorted = false;
			this._array.push(aMapping);
		}
	};
	/**
	* Returns the flat, sorted array of mappings. The mappings are sorted by
	* generated position.
	*
	* WARNING: This method returns internal data without copying, for
	* performance. The return value must NOT be mutated, and should be treated as
	* an immutable borrow. If you want to take ownership, you must make your own
	* copy.
	*/
	MappingList.prototype.toArray = function MappingList_toArray() {
		if (!this._sorted) {
			this._array.sort(util.compareByGeneratedPositionsInflated);
			this._sorted = true;
		}
		return this._array;
	};
	exports.MappingList = MappingList;
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/source-map-generator.js
var require_source_map_generator$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var base64VLQ = require_base64_vlq$1();
	var util = require_util$2();
	var ArraySet = require_array_set$1().ArraySet;
	var MappingList = require_mapping_list$1().MappingList;
	/**
	* An instance of the SourceMapGenerator represents a source map which is
	* being built incrementally. You may pass an object with the following
	* properties:
	*
	*   - file: The filename of the generated source.
	*   - sourceRoot: A root for all relative URLs in this source map.
	*/
	function SourceMapGenerator(aArgs) {
		if (!aArgs) aArgs = {};
		this._file = util.getArg(aArgs, "file", null);
		this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
		this._skipValidation = util.getArg(aArgs, "skipValidation", false);
		this._ignoreInvalidMapping = util.getArg(aArgs, "ignoreInvalidMapping", false);
		this._sources = new ArraySet();
		this._names = new ArraySet();
		this._mappings = new MappingList();
		this._sourcesContents = null;
	}
	SourceMapGenerator.prototype._version = 3;
	/**
	* Creates a new SourceMapGenerator based on a SourceMapConsumer
	*
	* @param aSourceMapConsumer The SourceMap.
	*/
	SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
		var sourceRoot = aSourceMapConsumer.sourceRoot;
		var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
			file: aSourceMapConsumer.file,
			sourceRoot
		}));
		aSourceMapConsumer.eachMapping(function(mapping) {
			var newMapping = { generated: {
				line: mapping.generatedLine,
				column: mapping.generatedColumn
			} };
			if (mapping.source != null) {
				newMapping.source = mapping.source;
				if (sourceRoot != null) newMapping.source = util.relative(sourceRoot, newMapping.source);
				newMapping.original = {
					line: mapping.originalLine,
					column: mapping.originalColumn
				};
				if (mapping.name != null) newMapping.name = mapping.name;
			}
			generator.addMapping(newMapping);
		});
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var sourceRelative = sourceFile;
			if (sourceRoot !== null) sourceRelative = util.relative(sourceRoot, sourceFile);
			if (!generator._sources.has(sourceRelative)) generator._sources.add(sourceRelative);
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) generator.setSourceContent(sourceFile, content);
		});
		return generator;
	};
	/**
	* Add a single mapping from original source line and column to the generated
	* source's line and column for this source map being created. The mapping
	* object should have the following properties:
	*
	*   - generated: An object with the generated line and column positions.
	*   - original: An object with the original line and column positions.
	*   - source: The original source file (relative to the sourceRoot).
	*   - name: An optional original token name for this mapping.
	*/
	SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
		var generated = util.getArg(aArgs, "generated");
		var original = util.getArg(aArgs, "original", null);
		var source = util.getArg(aArgs, "source", null);
		var name = util.getArg(aArgs, "name", null);
		if (!this._skipValidation) {
			if (this._validateMapping(generated, original, source, name) === false) return;
		}
		if (source != null) {
			source = String(source);
			if (!this._sources.has(source)) this._sources.add(source);
		}
		if (name != null) {
			name = String(name);
			if (!this._names.has(name)) this._names.add(name);
		}
		this._mappings.add({
			generatedLine: generated.line,
			generatedColumn: generated.column,
			originalLine: original != null && original.line,
			originalColumn: original != null && original.column,
			source,
			name
		});
	};
	/**
	* Set the source content for a source file.
	*/
	SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
		var source = aSourceFile;
		if (this._sourceRoot != null) source = util.relative(this._sourceRoot, source);
		if (aSourceContent != null) {
			if (!this._sourcesContents) this._sourcesContents = Object.create(null);
			this._sourcesContents[util.toSetString(source)] = aSourceContent;
		} else if (this._sourcesContents) {
			delete this._sourcesContents[util.toSetString(source)];
			if (Object.keys(this._sourcesContents).length === 0) this._sourcesContents = null;
		}
	};
	/**
	* Applies the mappings of a sub-source-map for a specific source file to the
	* source map being generated. Each mapping to the supplied source file is
	* rewritten using the supplied source map. Note: The resolution for the
	* resulting mappings is the minimium of this map and the supplied map.
	*
	* @param aSourceMapConsumer The source map to be applied.
	* @param aSourceFile Optional. The filename of the source file.
	*        If omitted, SourceMapConsumer's file property will be used.
	* @param aSourceMapPath Optional. The dirname of the path to the source map
	*        to be applied. If relative, it is relative to the SourceMapConsumer.
	*        This parameter is needed when the two source maps aren't in the same
	*        directory, and the source map to be applied contains relative source
	*        paths. If so, those relative source paths need to be rewritten
	*        relative to the SourceMapGenerator.
	*/
	SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
		var sourceFile = aSourceFile;
		if (aSourceFile == null) {
			if (aSourceMapConsumer.file == null) throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's \"file\" property. Both were omitted.");
			sourceFile = aSourceMapConsumer.file;
		}
		var sourceRoot = this._sourceRoot;
		if (sourceRoot != null) sourceFile = util.relative(sourceRoot, sourceFile);
		var newSources = new ArraySet();
		var newNames = new ArraySet();
		this._mappings.unsortedForEach(function(mapping) {
			if (mapping.source === sourceFile && mapping.originalLine != null) {
				var original = aSourceMapConsumer.originalPositionFor({
					line: mapping.originalLine,
					column: mapping.originalColumn
				});
				if (original.source != null) {
					mapping.source = original.source;
					if (aSourceMapPath != null) mapping.source = util.join(aSourceMapPath, mapping.source);
					if (sourceRoot != null) mapping.source = util.relative(sourceRoot, mapping.source);
					mapping.originalLine = original.line;
					mapping.originalColumn = original.column;
					if (original.name != null) mapping.name = original.name;
				}
			}
			var source = mapping.source;
			if (source != null && !newSources.has(source)) newSources.add(source);
			var name = mapping.name;
			if (name != null && !newNames.has(name)) newNames.add(name);
		}, this);
		this._sources = newSources;
		this._names = newNames;
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) {
				if (aSourceMapPath != null) sourceFile = util.join(aSourceMapPath, sourceFile);
				if (sourceRoot != null) sourceFile = util.relative(sourceRoot, sourceFile);
				this.setSourceContent(sourceFile, content);
			}
		}, this);
	};
	/**
	* A mapping can have one of the three levels of data:
	*
	*   1. Just the generated position.
	*   2. The Generated position, original position, and original source.
	*   3. Generated and original position, original source, as well as a name
	*      token.
	*
	* To maintain consistency, we validate that any new mapping being added falls
	* in to one of these categories.
	*/
	SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
		if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
			var message = "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.";
			if (this._ignoreInvalidMapping) {
				if (typeof console !== "undefined" && console.warn) console.warn(message);
				return false;
			} else throw new Error(message);
		}
		if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) return;
		else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) return;
		else {
			var message = "Invalid mapping: " + JSON.stringify({
				generated: aGenerated,
				source: aSource,
				original: aOriginal,
				name: aName
			});
			if (this._ignoreInvalidMapping) {
				if (typeof console !== "undefined" && console.warn) console.warn(message);
				return false;
			} else throw new Error(message);
		}
	};
	/**
	* Serialize the accumulated mappings in to the stream of base 64 VLQs
	* specified by the source map format.
	*/
	SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
		var previousGeneratedColumn = 0;
		var previousGeneratedLine = 1;
		var previousOriginalColumn = 0;
		var previousOriginalLine = 0;
		var previousName = 0;
		var previousSource = 0;
		var result = "";
		var next;
		var mapping;
		var nameIdx;
		var sourceIdx;
		var mappings = this._mappings.toArray();
		for (var i = 0, len = mappings.length; i < len; i++) {
			mapping = mappings[i];
			next = "";
			if (mapping.generatedLine !== previousGeneratedLine) {
				previousGeneratedColumn = 0;
				while (mapping.generatedLine !== previousGeneratedLine) {
					next += ";";
					previousGeneratedLine++;
				}
			} else if (i > 0) {
				if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) continue;
				next += ",";
			}
			next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
			previousGeneratedColumn = mapping.generatedColumn;
			if (mapping.source != null) {
				sourceIdx = this._sources.indexOf(mapping.source);
				next += base64VLQ.encode(sourceIdx - previousSource);
				previousSource = sourceIdx;
				next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
				previousOriginalLine = mapping.originalLine - 1;
				next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
				previousOriginalColumn = mapping.originalColumn;
				if (mapping.name != null) {
					nameIdx = this._names.indexOf(mapping.name);
					next += base64VLQ.encode(nameIdx - previousName);
					previousName = nameIdx;
				}
			}
			result += next;
		}
		return result;
	};
	SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
		return aSources.map(function(source) {
			if (!this._sourcesContents) return null;
			if (aSourceRoot != null) source = util.relative(aSourceRoot, source);
			var key = util.toSetString(source);
			return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
		}, this);
	};
	/**
	* Externalize the source map.
	*/
	SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
		var map = {
			version: this._version,
			sources: this._sources.toArray(),
			names: this._names.toArray(),
			mappings: this._serializeMappings()
		};
		if (this._file != null) map.file = this._file;
		if (this._sourceRoot != null) map.sourceRoot = this._sourceRoot;
		if (this._sourcesContents) map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
		return map;
	};
	/**
	* Render the source map being generated to a string.
	*/
	SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
		return JSON.stringify(this.toJSON());
	};
	exports.SourceMapGenerator = SourceMapGenerator;
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/binary-search.js
var require_binary_search$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	exports.GREATEST_LOWER_BOUND = 1;
	exports.LEAST_UPPER_BOUND = 2;
	/**
	* Recursive implementation of binary search.
	*
	* @param aLow Indices here and lower do not contain the needle.
	* @param aHigh Indices here and higher do not contain the needle.
	* @param aNeedle The element being searched for.
	* @param aHaystack The non-empty array being searched.
	* @param aCompare Function which takes two elements and returns -1, 0, or 1.
	* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
	*     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*/
	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
		var mid = Math.floor((aHigh - aLow) / 2) + aLow;
		var cmp = aCompare(aNeedle, aHaystack[mid], true);
		if (cmp === 0) return mid;
		else if (cmp > 0) {
			if (aHigh - mid > 1) return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
			if (aBias == exports.LEAST_UPPER_BOUND) return aHigh < aHaystack.length ? aHigh : -1;
			else return mid;
		} else {
			if (mid - aLow > 1) return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
			if (aBias == exports.LEAST_UPPER_BOUND) return mid;
			else return aLow < 0 ? -1 : aLow;
		}
	}
	/**
	* This is an implementation of binary search which will always try and return
	* the index of the closest element if there is no exact hit. This is because
	* mappings between original and generated line/col pairs are single points,
	* and there is an implicit region between each of them, so a miss just means
	* that you aren't on the very start of a region.
	*
	* @param aNeedle The element you are looking for.
	* @param aHaystack The array that is being searched.
	* @param aCompare A function which takes the needle and an element in the
	*     array and returns -1, 0, or 1 depending on whether the needle is less
	*     than, equal to, or greater than the element, respectively.
	* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
	*     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
	*/
	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
		if (aHaystack.length === 0) return -1;
		var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
		if (index < 0) return -1;
		while (index - 1 >= 0) {
			if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) break;
			--index;
		}
		return index;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/quick-sort.js
var require_quick_sort$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	function SortTemplate(comparator) {
		/**
		* Swap the elements indexed by `x` and `y` in the array `ary`.
		*
		* @param {Array} ary
		*        The array.
		* @param {Number} x
		*        The index of the first item.
		* @param {Number} y
		*        The index of the second item.
		*/
		function swap(ary, x, y) {
			var temp = ary[x];
			ary[x] = ary[y];
			ary[y] = temp;
		}
		/**
		* Returns a random integer within the range `low .. high` inclusive.
		*
		* @param {Number} low
		*        The lower bound on the range.
		* @param {Number} high
		*        The upper bound on the range.
		*/
		function randomIntInRange(low, high) {
			return Math.round(low + Math.random() * (high - low));
		}
		/**
		* The Quick Sort algorithm.
		*
		* @param {Array} ary
		*        An array to sort.
		* @param {function} comparator
		*        Function to use to compare two items.
		* @param {Number} p
		*        Start index of the array
		* @param {Number} r
		*        End index of the array
		*/
		function doQuickSort(ary, comparator, p, r) {
			if (p < r) {
				var pivotIndex = randomIntInRange(p, r);
				var i = p - 1;
				swap(ary, pivotIndex, r);
				var pivot = ary[r];
				for (var j = p; j < r; j++) if (comparator(ary[j], pivot, false) <= 0) {
					i += 1;
					swap(ary, i, j);
				}
				swap(ary, i + 1, j);
				var q = i + 1;
				doQuickSort(ary, comparator, p, q - 1);
				doQuickSort(ary, comparator, q + 1, r);
			}
		}
		return doQuickSort;
	}
	function cloneSort(comparator) {
		let template = SortTemplate.toString();
		return new Function(`return ${template}`)()(comparator);
	}
	/**
	* Sort the given array in-place with the given comparator function.
	*
	* @param {Array} ary
	*        An array to sort.
	* @param {function} comparator
	*        Function to use to compare two items.
	*/
	let sortCache = /* @__PURE__ */ new WeakMap();
	exports.quickSort = function(ary, comparator, start = 0) {
		let doQuickSort = sortCache.get(comparator);
		if (doQuickSort === void 0) {
			doQuickSort = cloneSort(comparator);
			sortCache.set(comparator, doQuickSort);
		}
		doQuickSort(ary, comparator, start, ary.length - 1);
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/source-map-consumer.js
var require_source_map_consumer$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util$2();
	var binarySearch = require_binary_search$1();
	var ArraySet = require_array_set$1().ArraySet;
	var base64VLQ = require_base64_vlq$1();
	var quickSort = require_quick_sort$1().quickSort;
	function SourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
	}
	SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
		return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
	};
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	SourceMapConsumer.prototype._version = 3;
	SourceMapConsumer.prototype.__generatedMappings = null;
	Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
		configurable: true,
		enumerable: true,
		get: function() {
			if (!this.__generatedMappings) this._parseMappings(this._mappings, this.sourceRoot);
			return this.__generatedMappings;
		}
	});
	SourceMapConsumer.prototype.__originalMappings = null;
	Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
		configurable: true,
		enumerable: true,
		get: function() {
			if (!this.__originalMappings) this._parseMappings(this._mappings, this.sourceRoot);
			return this.__originalMappings;
		}
	});
	SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
		var c = aStr.charAt(index);
		return c === ";" || c === ",";
	};
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		throw new Error("Subclasses must implement _parseMappings");
	};
	SourceMapConsumer.GENERATED_ORDER = 1;
	SourceMapConsumer.ORIGINAL_ORDER = 2;
	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
	/**
	* Iterate over each mapping between an original source/line/column and a
	* generated line/column in this source map.
	*
	* @param Function aCallback
	*        The function that is called with each mapping.
	* @param Object aContext
	*        Optional. If specified, this object will be the value of `this` every
	*        time that `aCallback` is called.
	* @param aOrder
	*        Either `SourceMapConsumer.GENERATED_ORDER` or
	*        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
	*        iterate over the mappings sorted by the generated file's line/column
	*        order or the original's source/line/column order, respectively. Defaults to
	*        `SourceMapConsumer.GENERATED_ORDER`.
	*/
	SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
		var context = aContext || null;
		var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
		var mappings;
		switch (order) {
			case SourceMapConsumer.GENERATED_ORDER:
				mappings = this._generatedMappings;
				break;
			case SourceMapConsumer.ORIGINAL_ORDER:
				mappings = this._originalMappings;
				break;
			default: throw new Error("Unknown order of iteration.");
		}
		var sourceRoot = this.sourceRoot;
		var boundCallback = aCallback.bind(context);
		var names = this._names;
		var sources = this._sources;
		var sourceMapURL = this._sourceMapURL;
		for (var i = 0, n = mappings.length; i < n; i++) {
			var mapping = mappings[i];
			var source = mapping.source === null ? null : sources.at(mapping.source);
			if (source !== null) source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
			boundCallback({
				source,
				generatedLine: mapping.generatedLine,
				generatedColumn: mapping.generatedColumn,
				originalLine: mapping.originalLine,
				originalColumn: mapping.originalColumn,
				name: mapping.name === null ? null : names.at(mapping.name)
			});
		}
	};
	/**
	* Returns all generated line and column information for the original source,
	* line, and column provided. If no column is provided, returns all mappings
	* corresponding to a either the line we are searching for or the next
	* closest line that has any mappings. Otherwise, returns all mappings
	* corresponding to the given line and either the column we are searching for
	* or the next closest column that has any offsets.
	*
	* The only argument is an object with the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number is 1-based.
	*   - column: Optional. the column number in the original source.
	*    The column number is 0-based.
	*
	* and an array of objects is returned, each with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*    line number is 1-based.
	*   - column: The column number in the generated source, or null.
	*    The column number is 0-based.
	*/
	SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
		var line = util.getArg(aArgs, "line");
		var needle = {
			source: util.getArg(aArgs, "source"),
			originalLine: line,
			originalColumn: util.getArg(aArgs, "column", 0)
		};
		needle.source = this._findSourceIndex(needle.source);
		if (needle.source < 0) return [];
		var mappings = [];
		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
		if (index >= 0) {
			var mapping = this._originalMappings[index];
			if (aArgs.column === void 0) {
				var originalLine = mapping.originalLine;
				while (mapping && mapping.originalLine === originalLine) {
					mappings.push({
						line: util.getArg(mapping, "generatedLine", null),
						column: util.getArg(mapping, "generatedColumn", null),
						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
					});
					mapping = this._originalMappings[++index];
				}
			} else {
				var originalColumn = mapping.originalColumn;
				while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
					mappings.push({
						line: util.getArg(mapping, "generatedLine", null),
						column: util.getArg(mapping, "generatedColumn", null),
						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
					});
					mapping = this._originalMappings[++index];
				}
			}
		}
		return mappings;
	};
	exports.SourceMapConsumer = SourceMapConsumer;
	/**
	* A BasicSourceMapConsumer instance represents a parsed source map which we can
	* query for information about the original file positions by giving it a file
	* position in the generated source.
	*
	* The first parameter is the raw source map (either as a JSON string, or
	* already parsed to an object). According to the spec, source maps have the
	* following attributes:
	*
	*   - version: Which version of the source map spec this map is following.
	*   - sources: An array of URLs to the original source files.
	*   - names: An array of identifiers which can be referrenced by individual mappings.
	*   - sourceRoot: Optional. The URL root from which all sources are relative.
	*   - sourcesContent: Optional. An array of contents of the original source files.
	*   - mappings: A string of base64 VLQs which contain the actual mappings.
	*   - file: Optional. The generated file this source map is associated with.
	*
	* Here is an example source map, taken from the source map spec[0]:
	*
	*     {
	*       version : 3,
	*       file: "out.js",
	*       sourceRoot : "",
	*       sources: ["foo.js", "bar.js"],
	*       names: ["src", "maps", "are", "fun"],
	*       mappings: "AA,AB;;ABCDE;"
	*     }
	*
	* The second parameter, if given, is a string whose value is the URL
	* at which the source map was found.  This URL is used to compute the
	* sources array.
	*
	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
	*/
	function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		var version = util.getArg(sourceMap, "version");
		var sources = util.getArg(sourceMap, "sources");
		var names = util.getArg(sourceMap, "names", []);
		var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
		var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
		var mappings = util.getArg(sourceMap, "mappings");
		var file = util.getArg(sourceMap, "file", null);
		if (version != this._version) throw new Error("Unsupported version: " + version);
		if (sourceRoot) sourceRoot = util.normalize(sourceRoot);
		sources = sources.map(String).map(util.normalize).map(function(source) {
			return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
		});
		this._names = ArraySet.fromArray(names.map(String), true);
		this._sources = ArraySet.fromArray(sources, true);
		this._absoluteSources = this._sources.toArray().map(function(s) {
			return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
		});
		this.sourceRoot = sourceRoot;
		this.sourcesContent = sourcesContent;
		this._mappings = mappings;
		this._sourceMapURL = aSourceMapURL;
		this.file = file;
	}
	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
	/**
	* Utility function to find the index of a source.  Returns -1 if not
	* found.
	*/
	BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
		var relativeSource = aSource;
		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
		if (this._sources.has(relativeSource)) return this._sources.indexOf(relativeSource);
		var i;
		for (i = 0; i < this._absoluteSources.length; ++i) if (this._absoluteSources[i] == aSource) return i;
		return -1;
	};
	/**
	* Create a BasicSourceMapConsumer from a SourceMapGenerator.
	*
	* @param SourceMapGenerator aSourceMap
	*        The source map that will be consumed.
	* @param String aSourceMapURL
	*        The URL at which the source map can be found (optional)
	* @returns BasicSourceMapConsumer
	*/
	BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
		var smc = Object.create(BasicSourceMapConsumer.prototype);
		var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
		var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
		smc.sourceRoot = aSourceMap._sourceRoot;
		smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
		smc.file = aSourceMap._file;
		smc._sourceMapURL = aSourceMapURL;
		smc._absoluteSources = smc._sources.toArray().map(function(s) {
			return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
		});
		var generatedMappings = aSourceMap._mappings.toArray().slice();
		var destGeneratedMappings = smc.__generatedMappings = [];
		var destOriginalMappings = smc.__originalMappings = [];
		for (var i = 0, length = generatedMappings.length; i < length; i++) {
			var srcMapping = generatedMappings[i];
			var destMapping = new Mapping();
			destMapping.generatedLine = srcMapping.generatedLine;
			destMapping.generatedColumn = srcMapping.generatedColumn;
			if (srcMapping.source) {
				destMapping.source = sources.indexOf(srcMapping.source);
				destMapping.originalLine = srcMapping.originalLine;
				destMapping.originalColumn = srcMapping.originalColumn;
				if (srcMapping.name) destMapping.name = names.indexOf(srcMapping.name);
				destOriginalMappings.push(destMapping);
			}
			destGeneratedMappings.push(destMapping);
		}
		quickSort(smc.__originalMappings, util.compareByOriginalPositions);
		return smc;
	};
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	BasicSourceMapConsumer.prototype._version = 3;
	/**
	* The list of original sources.
	*/
	Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { get: function() {
		return this._absoluteSources.slice();
	} });
	/**
	* Provide the JIT with a nice shape / hidden class.
	*/
	function Mapping() {
		this.generatedLine = 0;
		this.generatedColumn = 0;
		this.source = null;
		this.originalLine = null;
		this.originalColumn = null;
		this.name = null;
	}
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	const compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
	function sortGenerated(array, start) {
		let l = array.length;
		let n = array.length - start;
		if (n <= 1) return;
		else if (n == 2) {
			let a = array[start];
			let b = array[start + 1];
			if (compareGenerated(a, b) > 0) {
				array[start] = b;
				array[start + 1] = a;
			}
		} else if (n < 20) for (let i = start; i < l; i++) for (let j = i; j > start; j--) {
			let a = array[j - 1];
			let b = array[j];
			if (compareGenerated(a, b) <= 0) break;
			array[j - 1] = b;
			array[j] = a;
		}
		else quickSort(array, compareGenerated, start);
	}
	BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		var generatedLine = 1;
		var previousGeneratedColumn = 0;
		var previousOriginalLine = 0;
		var previousOriginalColumn = 0;
		var previousSource = 0;
		var previousName = 0;
		var length = aStr.length;
		var index = 0;
		var temp = {};
		var originalMappings = [];
		var generatedMappings = [], mapping, segment, end, value;
		let subarrayStart = 0;
		while (index < length) if (aStr.charAt(index) === ";") {
			generatedLine++;
			index++;
			previousGeneratedColumn = 0;
			sortGenerated(generatedMappings, subarrayStart);
			subarrayStart = generatedMappings.length;
		} else if (aStr.charAt(index) === ",") index++;
		else {
			mapping = new Mapping();
			mapping.generatedLine = generatedLine;
			for (end = index; end < length; end++) if (this._charIsMappingSeparator(aStr, end)) break;
			aStr.slice(index, end);
			segment = [];
			while (index < end) {
				base64VLQ.decode(aStr, index, temp);
				value = temp.value;
				index = temp.rest;
				segment.push(value);
			}
			if (segment.length === 2) throw new Error("Found a source, but no line and column");
			if (segment.length === 3) throw new Error("Found a source and line, but no column");
			mapping.generatedColumn = previousGeneratedColumn + segment[0];
			previousGeneratedColumn = mapping.generatedColumn;
			if (segment.length > 1) {
				mapping.source = previousSource + segment[1];
				previousSource += segment[1];
				mapping.originalLine = previousOriginalLine + segment[2];
				previousOriginalLine = mapping.originalLine;
				mapping.originalLine += 1;
				mapping.originalColumn = previousOriginalColumn + segment[3];
				previousOriginalColumn = mapping.originalColumn;
				if (segment.length > 4) {
					mapping.name = previousName + segment[4];
					previousName += segment[4];
				}
			}
			generatedMappings.push(mapping);
			if (typeof mapping.originalLine === "number") {
				let currentSource = mapping.source;
				while (originalMappings.length <= currentSource) originalMappings.push(null);
				if (originalMappings[currentSource] === null) originalMappings[currentSource] = [];
				originalMappings[currentSource].push(mapping);
			}
		}
		sortGenerated(generatedMappings, subarrayStart);
		this.__generatedMappings = generatedMappings;
		for (var i = 0; i < originalMappings.length; i++) if (originalMappings[i] != null) quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
		this.__originalMappings = [].concat(...originalMappings);
	};
	/**
	* Find the mapping that best matches the hypothetical "needle" mapping that
	* we are searching for in the given "haystack" of mappings.
	*/
	BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
		if (aNeedle[aLineName] <= 0) throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
		if (aNeedle[aColumnName] < 0) throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
		return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
	};
	/**
	* Compute the last column for each generated mapping. The last column is
	* inclusive.
	*/
	BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
		for (var index = 0; index < this._generatedMappings.length; ++index) {
			var mapping = this._generatedMappings[index];
			if (index + 1 < this._generatedMappings.length) {
				var nextMapping = this._generatedMappings[index + 1];
				if (mapping.generatedLine === nextMapping.generatedLine) {
					mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
					continue;
				}
			}
			mapping.lastGeneratedColumn = Infinity;
		}
	};
	/**
	* Returns the original source, line, and column information for the generated
	* source's line and column positions provided. The only argument is an object
	* with the following properties:
	*
	*   - line: The line number in the generated source.  The line number
	*     is 1-based.
	*   - column: The column number in the generated source.  The column
	*     number is 0-based.
	*   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
	*     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
	*
	* and an object is returned with the following properties:
	*
	*   - source: The original source file, or null.
	*   - line: The line number in the original source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the original source, or null.  The
	*     column number is 0-based.
	*   - name: The original identifier, or null.
	*/
	BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
		var needle = {
			generatedLine: util.getArg(aArgs, "line"),
			generatedColumn: util.getArg(aArgs, "column")
		};
		var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
		if (index >= 0) {
			var mapping = this._generatedMappings[index];
			if (mapping.generatedLine === needle.generatedLine) {
				var source = util.getArg(mapping, "source", null);
				if (source !== null) {
					source = this._sources.at(source);
					source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
				}
				var name = util.getArg(mapping, "name", null);
				if (name !== null) name = this._names.at(name);
				return {
					source,
					line: util.getArg(mapping, "originalLine", null),
					column: util.getArg(mapping, "originalColumn", null),
					name
				};
			}
		}
		return {
			source: null,
			line: null,
			column: null,
			name: null
		};
	};
	/**
	* Return true if we have the source content for every source in the source
	* map, false otherwise.
	*/
	BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
		if (!this.sourcesContent) return false;
		return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
			return sc == null;
		});
	};
	/**
	* Returns the original source content. The only argument is the url of the
	* original source file. Returns null if no original source content is
	* available.
	*/
	BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
		if (!this.sourcesContent) return null;
		var index = this._findSourceIndex(aSource);
		if (index >= 0) return this.sourcesContent[index];
		var relativeSource = aSource;
		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
		var url;
		if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
			var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
			if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
			if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
		}
		if (nullOnMissing) return null;
		else throw new Error("\"" + relativeSource + "\" is not in the SourceMap.");
	};
	/**
	* Returns the generated line and column information for the original source,
	* line, and column positions provided. The only argument is an object with
	* the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number
	*     is 1-based.
	*   - column: The column number in the original source.  The column
	*     number is 0-based.
	*   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
	*     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
	*
	* and an object is returned with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the generated source, or null.
	*     The column number is 0-based.
	*/
	BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
		var source = util.getArg(aArgs, "source");
		source = this._findSourceIndex(source);
		if (source < 0) return {
			line: null,
			column: null,
			lastColumn: null
		};
		var needle = {
			source,
			originalLine: util.getArg(aArgs, "line"),
			originalColumn: util.getArg(aArgs, "column")
		};
		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
		if (index >= 0) {
			var mapping = this._originalMappings[index];
			if (mapping.source === needle.source) return {
				line: util.getArg(mapping, "generatedLine", null),
				column: util.getArg(mapping, "generatedColumn", null),
				lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
			};
		}
		return {
			line: null,
			column: null,
			lastColumn: null
		};
	};
	exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
	/**
	* An IndexedSourceMapConsumer instance represents a parsed source map which
	* we can query for information. It differs from BasicSourceMapConsumer in
	* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
	* input.
	*
	* The first parameter is a raw source map (either as a JSON string, or already
	* parsed to an object). According to the spec for indexed source maps, they
	* have the following attributes:
	*
	*   - version: Which version of the source map spec this map is following.
	*   - file: Optional. The generated file this source map is associated with.
	*   - sections: A list of section definitions.
	*
	* Each value under the "sections" field has two fields:
	*   - offset: The offset into the original specified at which this section
	*       begins to apply, defined as an object with a "line" and "column"
	*       field.
	*   - map: A source map definition. This source map could also be indexed,
	*       but doesn't have to be.
	*
	* Instead of the "map" field, it's also possible to have a "url" field
	* specifying a URL to retrieve a source map from, but that's currently
	* unsupported.
	*
	* Here's an example source map, taken from the source map spec[0], but
	* modified to omit a section which uses the "url" field.
	*
	*  {
	*    version : 3,
	*    file: "app.js",
	*    sections: [{
	*      offset: {line:100, column:10},
	*      map: {
	*        version : 3,
	*        file: "section.js",
	*        sources: ["foo.js", "bar.js"],
	*        names: ["src", "maps", "are", "fun"],
	*        mappings: "AAAA,E;;ABCDE;"
	*      }
	*    }],
	*  }
	*
	* The second parameter, if given, is a string whose value is the URL
	* at which the source map was found.  This URL is used to compute the
	* sources array.
	*
	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
	*/
	function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		var version = util.getArg(sourceMap, "version");
		var sections = util.getArg(sourceMap, "sections");
		if (version != this._version) throw new Error("Unsupported version: " + version);
		this._sources = new ArraySet();
		this._names = new ArraySet();
		var lastOffset = {
			line: -1,
			column: 0
		};
		this._sections = sections.map(function(s) {
			if (s.url) throw new Error("Support for url field in sections not implemented.");
			var offset = util.getArg(s, "offset");
			var offsetLine = util.getArg(offset, "line");
			var offsetColumn = util.getArg(offset, "column");
			if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) throw new Error("Section offsets must be ordered and non-overlapping.");
			lastOffset = offset;
			return {
				generatedOffset: {
					generatedLine: offsetLine + 1,
					generatedColumn: offsetColumn + 1
				},
				consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
			};
		});
	}
	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	IndexedSourceMapConsumer.prototype._version = 3;
	/**
	* The list of original sources.
	*/
	Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { get: function() {
		var sources = [];
		for (var i = 0; i < this._sections.length; i++) for (var j = 0; j < this._sections[i].consumer.sources.length; j++) sources.push(this._sections[i].consumer.sources[j]);
		return sources;
	} });
	/**
	* Returns the original source, line, and column information for the generated
	* source's line and column positions provided. The only argument is an object
	* with the following properties:
	*
	*   - line: The line number in the generated source.  The line number
	*     is 1-based.
	*   - column: The column number in the generated source.  The column
	*     number is 0-based.
	*
	* and an object is returned with the following properties:
	*
	*   - source: The original source file, or null.
	*   - line: The line number in the original source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the original source, or null.  The
	*     column number is 0-based.
	*   - name: The original identifier, or null.
	*/
	IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
		var needle = {
			generatedLine: util.getArg(aArgs, "line"),
			generatedColumn: util.getArg(aArgs, "column")
		};
		var sectionIndex = binarySearch.search(needle, this._sections, function(needle, section) {
			var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
			if (cmp) return cmp;
			return needle.generatedColumn - section.generatedOffset.generatedColumn;
		});
		var section = this._sections[sectionIndex];
		if (!section) return {
			source: null,
			line: null,
			column: null,
			name: null
		};
		return section.consumer.originalPositionFor({
			line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
			column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
			bias: aArgs.bias
		});
	};
	/**
	* Return true if we have the source content for every source in the source
	* map, false otherwise.
	*/
	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
		return this._sections.every(function(s) {
			return s.consumer.hasContentsOfAllSources();
		});
	};
	/**
	* Returns the original source content. The only argument is the url of the
	* original source file. Returns null if no original source content is
	* available.
	*/
	IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
		for (var i = 0; i < this._sections.length; i++) {
			var content = this._sections[i].consumer.sourceContentFor(aSource, true);
			if (content || content === "") return content;
		}
		if (nullOnMissing) return null;
		else throw new Error("\"" + aSource + "\" is not in the SourceMap.");
	};
	/**
	* Returns the generated line and column information for the original source,
	* line, and column positions provided. The only argument is an object with
	* the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number
	*     is 1-based.
	*   - column: The column number in the original source.  The column
	*     number is 0-based.
	*
	* and an object is returned with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*     line number is 1-based. 
	*   - column: The column number in the generated source, or null.
	*     The column number is 0-based.
	*/
	IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
		for (var i = 0; i < this._sections.length; i++) {
			var section = this._sections[i];
			if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) continue;
			var generatedPosition = section.consumer.generatedPositionFor(aArgs);
			if (generatedPosition) return {
				line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
				column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
			};
		}
		return {
			line: null,
			column: null
		};
	};
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		this.__generatedMappings = [];
		this.__originalMappings = [];
		for (var i = 0; i < this._sections.length; i++) {
			var section = this._sections[i];
			var sectionMappings = section.consumer._generatedMappings;
			for (var j = 0; j < sectionMappings.length; j++) {
				var mapping = sectionMappings[j];
				var source = section.consumer._sources.at(mapping.source);
				if (source !== null) source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
				this._sources.add(source);
				source = this._sources.indexOf(source);
				var name = null;
				if (mapping.name) {
					name = section.consumer._names.at(mapping.name);
					this._names.add(name);
					name = this._names.indexOf(name);
				}
				var adjustedMapping = {
					source,
					generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
					generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
					originalLine: mapping.originalLine,
					originalColumn: mapping.originalColumn,
					name
				};
				this.__generatedMappings.push(adjustedMapping);
				if (typeof adjustedMapping.originalLine === "number") this.__originalMappings.push(adjustedMapping);
			}
		}
		quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
		quickSort(this.__originalMappings, util.compareByOriginalPositions);
	};
	exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
}));
//#endregion
//#region node_modules/.pnpm/source-map-js@1.2.1/node_modules/source-map-js/lib/source-node.js
var require_source_node$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var SourceMapGenerator = require_source_map_generator$1().SourceMapGenerator;
	var util = require_util$2();
	var REGEX_NEWLINE = /(\r?\n)/;
	var NEWLINE_CODE = 10;
	var isSourceNode = "$$$isSourceNode$$$";
	/**
	* SourceNodes provide a way to abstract over interpolating/concatenating
	* snippets of generated JavaScript source code while maintaining the line and
	* column information associated with the original source code.
	*
	* @param aLine The original line number.
	* @param aColumn The original column number.
	* @param aSource The original source's filename.
	* @param aChunks Optional. An array of strings which are snippets of
	*        generated JS, or other SourceNodes.
	* @param aName The original identifier.
	*/
	function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
		this.children = [];
		this.sourceContents = {};
		this.line = aLine == null ? null : aLine;
		this.column = aColumn == null ? null : aColumn;
		this.source = aSource == null ? null : aSource;
		this.name = aName == null ? null : aName;
		this[isSourceNode] = true;
		if (aChunks != null) this.add(aChunks);
	}
	/**
	* Creates a SourceNode from generated code and a SourceMapConsumer.
	*
	* @param aGeneratedCode The generated code
	* @param aSourceMapConsumer The SourceMap for the generated code
	* @param aRelativePath Optional. The path that relative sources in the
	*        SourceMapConsumer should be relative to.
	*/
	SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
		var node = new SourceNode();
		var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
		var remainingLinesIndex = 0;
		var shiftNextLine = function() {
			return getNextLine() + (getNextLine() || "");
			function getNextLine() {
				return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
			}
		};
		var lastGeneratedLine = 1, lastGeneratedColumn = 0;
		var lastMapping = null;
		aSourceMapConsumer.eachMapping(function(mapping) {
			if (lastMapping !== null) {
				if (lastGeneratedLine < mapping.generatedLine) {
					addMappingWithCode(lastMapping, shiftNextLine());
					lastGeneratedLine++;
					lastGeneratedColumn = 0;
				} else {
					var nextLine = remainingLines[remainingLinesIndex] || "";
					var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
					remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
					lastGeneratedColumn = mapping.generatedColumn;
					addMappingWithCode(lastMapping, code);
					lastMapping = mapping;
					return;
				}
			}
			while (lastGeneratedLine < mapping.generatedLine) {
				node.add(shiftNextLine());
				lastGeneratedLine++;
			}
			if (lastGeneratedColumn < mapping.generatedColumn) {
				var nextLine = remainingLines[remainingLinesIndex] || "";
				node.add(nextLine.substr(0, mapping.generatedColumn));
				remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
				lastGeneratedColumn = mapping.generatedColumn;
			}
			lastMapping = mapping;
		}, this);
		if (remainingLinesIndex < remainingLines.length) {
			if (lastMapping) addMappingWithCode(lastMapping, shiftNextLine());
			node.add(remainingLines.splice(remainingLinesIndex).join(""));
		}
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) {
				if (aRelativePath != null) sourceFile = util.join(aRelativePath, sourceFile);
				node.setSourceContent(sourceFile, content);
			}
		});
		return node;
		function addMappingWithCode(mapping, code) {
			if (mapping === null || mapping.source === void 0) node.add(code);
			else {
				var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
				node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
			}
		}
	};
	/**
	* Add a chunk of generated JS to this source node.
	*
	* @param aChunk A string snippet of generated JS code, another instance of
	*        SourceNode, or an array where each member is one of those things.
	*/
	SourceNode.prototype.add = function SourceNode_add(aChunk) {
		if (Array.isArray(aChunk)) aChunk.forEach(function(chunk) {
			this.add(chunk);
		}, this);
		else if (aChunk[isSourceNode] || typeof aChunk === "string") {
			if (aChunk) this.children.push(aChunk);
		} else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
		return this;
	};
	/**
	* Add a chunk of generated JS to the beginning of this source node.
	*
	* @param aChunk A string snippet of generated JS code, another instance of
	*        SourceNode, or an array where each member is one of those things.
	*/
	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
		if (Array.isArray(aChunk)) for (var i = aChunk.length - 1; i >= 0; i--) this.prepend(aChunk[i]);
		else if (aChunk[isSourceNode] || typeof aChunk === "string") this.children.unshift(aChunk);
		else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
		return this;
	};
	/**
	* Walk over the tree of JS snippets in this node and its children. The
	* walking function is called once for each snippet of JS and is passed that
	* snippet and the its original associated source's line/column location.
	*
	* @param aFn The traversal function.
	*/
	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
		var chunk;
		for (var i = 0, len = this.children.length; i < len; i++) {
			chunk = this.children[i];
			if (chunk[isSourceNode]) chunk.walk(aFn);
			else if (chunk !== "") aFn(chunk, {
				source: this.source,
				line: this.line,
				column: this.column,
				name: this.name
			});
		}
	};
	/**
	* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
	* each of `this.children`.
	*
	* @param aSep The separator.
	*/
	SourceNode.prototype.join = function SourceNode_join(aSep) {
		var newChildren;
		var i;
		var len = this.children.length;
		if (len > 0) {
			newChildren = [];
			for (i = 0; i < len - 1; i++) {
				newChildren.push(this.children[i]);
				newChildren.push(aSep);
			}
			newChildren.push(this.children[i]);
			this.children = newChildren;
		}
		return this;
	};
	/**
	* Call String.prototype.replace on the very right-most source snippet. Useful
	* for trimming whitespace from the end of a source node, etc.
	*
	* @param aPattern The pattern to replace.
	* @param aReplacement The thing to replace the pattern with.
	*/
	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
		var lastChild = this.children[this.children.length - 1];
		if (lastChild[isSourceNode]) lastChild.replaceRight(aPattern, aReplacement);
		else if (typeof lastChild === "string") this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
		else this.children.push("".replace(aPattern, aReplacement));
		return this;
	};
	/**
	* Set the source content for a source file. This will be added to the SourceMapGenerator
	* in the sourcesContent field.
	*
	* @param aSourceFile The filename of the source file
	* @param aSourceContent The content of the source file
	*/
	SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
		this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
	};
	/**
	* Walk over the tree of SourceNodes. The walking function is called for each
	* source file content and is passed the filename and source content.
	*
	* @param aFn The traversal function.
	*/
	SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
		for (var i = 0, len = this.children.length; i < len; i++) if (this.children[i][isSourceNode]) this.children[i].walkSourceContents(aFn);
		var sources = Object.keys(this.sourceContents);
		for (var i = 0, len = sources.length; i < len; i++) aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
	};
	/**
	* Return the string representation of this source node. Walks over the tree
	* and concatenates all the various snippets together to one string.
	*/
	SourceNode.prototype.toString = function SourceNode_toString() {
		var str = "";
		this.walk(function(chunk) {
			str += chunk;
		});
		return str;
	};
	/**
	* Returns the string representation of this source node along with a source
	* map.
	*/
	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
		var generated = {
			code: "",
			line: 1,
			column: 0
		};
		var map = new SourceMapGenerator(aArgs);
		var sourceMappingActive = false;
		var lastOriginalSource = null;
		var lastOriginalLine = null;
		var lastOriginalColumn = null;
		var lastOriginalName = null;
		this.walk(function(chunk, original) {
			generated.code += chunk;
			if (original.source !== null && original.line !== null && original.column !== null) {
				if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) map.addMapping({
					source: original.source,
					original: {
						line: original.line,
						column: original.column
					},
					generated: {
						line: generated.line,
						column: generated.column
					},
					name: original.name
				});
				lastOriginalSource = original.source;
				lastOriginalLine = original.line;
				lastOriginalColumn = original.column;
				lastOriginalName = original.name;
				sourceMappingActive = true;
			} else if (sourceMappingActive) {
				map.addMapping({ generated: {
					line: generated.line,
					column: generated.column
				} });
				lastOriginalSource = null;
				sourceMappingActive = false;
			}
			for (var idx = 0, length = chunk.length; idx < length; idx++) if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
				generated.line++;
				generated.column = 0;
				if (idx + 1 === length) {
					lastOriginalSource = null;
					sourceMappingActive = false;
				} else if (sourceMappingActive) map.addMapping({
					source: original.source,
					original: {
						line: original.line,
						column: original.column
					},
					generated: {
						line: generated.line,
						column: generated.column
					},
					name: original.name
				});
			} else generated.column++;
		});
		this.walkSourceContents(function(sourceFile, sourceContent) {
			map.setSourceContent(sourceFile, sourceContent);
		});
		return {
			code: generated.code,
			map
		};
	};
	exports.SourceNode = SourceNode;
}));
//#endregion
//#region packages/compiler-core/src/codegen.ts
var import_source_map = (/* @__PURE__ */ __commonJSMin(((exports) => {
	exports.SourceMapGenerator = require_source_map_generator$1().SourceMapGenerator;
	exports.SourceMapConsumer = require_source_map_consumer$1().SourceMapConsumer;
	exports.SourceNode = require_source_node$1().SourceNode;
})))();
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;
			if (context.map) {
				if (node) {
					let name;
					if (node.type === 4 && !node.isStatic) {
						const content = node.content.replace(/^_ctx\./, "");
						if (content !== node.content && isSimpleIdentifier(content)) name = content;
					}
					if (node.loc.source) addMapping(node.loc.start, name);
				}
				if (newlineIndex === -3) advancePositionWithMutation(context, code);
				else {
					context.offset += code.length;
					if (newlineIndex === -2) context.column += code.length;
					else {
						if (newlineIndex === -1) newlineIndex = code.length - 1;
						context.line++;
						context.column = code.length - newlineIndex;
					}
				}
				if (node && node.loc !== locStub && node.loc.source) addMapping(node.loc.end);
			}
		},
		indent() {
			newline(++context.indentLevel);
		},
		deindent(withoutNewLine = false) {
			if (withoutNewLine) --context.indentLevel;
			else newline(--context.indentLevel);
		},
		newline() {
			newline(context.indentLevel);
		}
	};
	function newline(n) {
		context.push("\n" + `  `.repeat(n), 0);
	}
	function addMapping(loc, name = null) {
		const { _names, _mappings } = context.map;
		if (name !== null && !_names.has(name)) _names.add(name);
		_mappings.add({
			originalLine: loc.line,
			originalColumn: loc.column - 1,
			generatedLine: context.line,
			generatedColumn: context.column - 1,
			source: filename,
			name
		});
	}
	if (sourceMap) {
		context.map = new import_source_map.SourceMapGenerator();
		context.map.setSourceContent(filename, context.source);
		context.map._sources.add(filename);
	}
	return context;
}
function generate$1(ast, options = {}) {
	const context = createCodegenContext(ast, options);
	if (options.onContextCreated) options.onContextCreated(context);
	const { mode, push, prefixIdentifiers, indent, deindent, newline, scopeId, ssr } = context;
	const helpers = Array.from(ast.helpers);
	const hasHelpers = helpers.length > 0;
	const useWithBlock = !prefixIdentifiers && mode !== "module";
	const genScopeId = scopeId != null && mode === "module";
	const isSetupInlined = !!options.inline;
	const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;
	if (mode === "module") genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);
	else genFunctionPreamble(ast, preambleContext);
	const functionName = ssr ? `ssrRender` : `render`;
	const args = ssr ? [
		"_ctx",
		"_push",
		"_parent",
		"_attrs"
	] : ["_ctx", "_cache"];
	if (options.bindingMetadata && !options.inline) args.push("$props", "$setup", "$data", "$options");
	const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", ");
	if (isSetupInlined) push(`(${signature}) => {`);
	else push(`function ${functionName}(${signature}) {`);
	indent();
	if (useWithBlock) {
		push(`with (_ctx) {`);
		indent();
		if (hasHelpers) {
			push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue\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.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: isSetupInlined ? preambleContext.code : ``,
		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 = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;
	const helpers = Array.from(ast.helpers);
	if (helpers.length > 0) {
		if (prefixIdentifiers) push(`const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding}\n`, -1);
		else {
			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);
		}
	}
	if (ast.ssrHelpers && ast.ssrHelpers.length) push(`const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}")\n`, -1);
	genHoists(ast.hoists, context);
	newline();
	push(`return `);
}
function genModulePreamble(ast, context, genScopeId, inline) {
	const { push, newline, optimizeImports, runtimeModuleName, ssrRuntimeModuleName } = context;
	if (ast.helpers.size) {
		const helpers = Array.from(ast.helpers);
		if (optimizeImports) {
			push(`import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)}\n`, -1);
			push(`\n// Binding optimization for webpack code-split\nconst ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")}\n`, -1);
		} else push(`import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)}\n`, -1);
	}
	if (ast.ssrHelpers && ast.ssrHelpers.length) push(`import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}"\n`, -1);
	if (ast.imports.length) {
		genImports(ast.imports, context);
		newline();
	}
	genHoists(ast.hoists, context);
	newline();
	if (!inline) push(`export `);
}
function genAssets(assets, type, { helper, push, newline, isTS }) {
	const resolver = helper(type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE);
	for (let i = 0; i < assets.length; i++) {
		let id = assets[i];
		const maybeSelfReference = id.endsWith("__self");
		if (maybeSelfReference) id = id.slice(0, -6);
		push(`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`);
		if (i < assets.length - 1) newline();
	}
}
function genHoists(hoists, context) {
	if (!hoists.length) return;
	context.pure = true;
	const { push, newline } = context;
	newline();
	for (let i = 0; i < hoists.length; i++) {
		const exp = hoists[i];
		if (exp) {
			push(`const _hoisted_${i + 1} = `);
			genNode(exp, context);
			newline();
		}
	}
	context.pure = false;
}
function genImports(importsOptions, context) {
	if (!importsOptions.length) return;
	importsOptions.forEach((imports) => {
		context.push(`import `);
		genNode(imports.exp, context);
		context.push(` from '${imports.path}'`);
		context.newline();
	});
}
function isText(n) {
	return isString$1(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$3(n) || !isText(n));
	context.push(`[`);
	multilines && context.indent();
	genNodeList(nodes, context, multilines);
	multilines && context.deindent();
	context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
	const { push, newline } = context;
	for (let i = 0; i < nodes.length; i++) {
		const node = nodes[i];
		if (isString$1(node)) push(node, -3);
		else if (isArray$3(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$1(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$1(node, context);
			break;
		case 5:
			genInterpolation(node, context);
			break;
		case 12:
			genNode(node.codegenNode, context);
			break;
		case 8:
			genCompoundExpression(node, context);
			break;
		case 3:
			genComment(node, context);
			break;
		case 13:
			genVNodeCall(node, context);
			break;
		case 14:
			genCallExpression(node, context);
			break;
		case 15:
			genObjectExpression(node, context);
			break;
		case 17:
			genArrayExpression(node, context);
			break;
		case 18:
			genFunctionExpression(node, context);
			break;
		case 19:
			genConditionalExpression(node, context);
			break;
		case 20:
			genCacheExpression(node, context);
			break;
		case 21:
			genNodeList(node.body, context, true, false);
			break;
		case 22:
			genTemplateLiteral(node, context);
			break;
		case 23:
			genIfStatement(node, context);
			break;
		case 24:
			genAssignmentExpression(node, context);
			break;
		case 25:
			genSequenceExpression(node, context);
			break;
		case 26:
			genReturnStatement(node, context);
			break;
		/* 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$1(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$1(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$1(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$3(params)) genNodeList(params, context);
	else if (params) genNode(params, context);
	push(`) => `);
	if (newline || body) {
		push(`{`);
		indent();
	}
	if (returns) {
		if (newline) push(`return `);
		if (isArray$3(returns)) genNodeListAsArray(returns, context);
		else genNode(returns, context);
	} else if (body) genNode(body, context);
	if (newline || body) {
		deindent();
		push(`}`);
	}
	if (isSlot) 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$1(test, context);
		needsParens && push(`)`);
	} else {
		push(`(`);
		genNode(test, context);
		push(`)`);
	}
	needNewline && indent();
	context.indentLevel++;
	needNewline || push(` `);
	push(`? `);
	genNode(consequent, context);
	context.indentLevel--;
	needNewline && newline();
	needNewline || push(` `);
	push(`: `);
	const isNested = alternate.type === 19;
	if (!isNested) context.indentLevel++;
	genNode(alternate, context);
	if (!isNested) context.indentLevel--;
	needNewline && deindent(true);
}
function genCacheExpression(node, context) {
	const { push, helper, indent, deindent, newline } = context;
	const { needPauseTracking, needArraySpread } = node;
	if (needArraySpread) push(`[...(`);
	push(`_cache[${node.index}] || (`);
	if (needPauseTracking) {
		indent();
		push(`${helper(SET_BLOCK_TRACKING)}(-1`);
		if (node.inVOnce) push(`, true`);
		push(`),`);
		newline();
		push(`(`);
	}
	push(`_cache[${node.index}] = `);
	genNode(node.value, context);
	if (needPauseTracking) {
		push(`).cacheIndex = ${node.index},`);
		newline();
		push(`${helper(SET_BLOCK_TRACKING)}(1),`);
		newline();
		push(`_cache[${node.index}]`);
		deindent();
	}
	push(`)`);
	if (needArraySpread) push(`)]`);
}
function genTemplateLiteral(node, context) {
	const { push, indent, deindent } = context;
	push("`");
	const l = node.elements.length;
	const multilines = l > 3;
	for (let i = 0; i < l; i++) {
		const e = node.elements[i];
		if (isString$1(e)) push(e.replace(/(`|\$|\\)/g, "\\$1"), -3);
		else {
			push("${");
			if (multilines) indent();
			genNode(e, context);
			if (multilines) deindent();
			push("}");
		}
	}
	push("`");
}
function genIfStatement(node, context) {
	const { push, indent, deindent } = context;
	const { test, consequent, alternate } = node;
	push(`if (`);
	genNode(test, context);
	push(`) {`);
	indent();
	genNode(consequent, context);
	deindent();
	push(`}`);
	if (alternate) {
		push(` else `);
		if (alternate.type === 23) genIfStatement(alternate, context);
		else {
			push(`{`);
			indent();
			genNode(alternate, context);
			deindent();
			push(`}`);
		}
	}
}
function genAssignmentExpression(node, context) {
	genNode(node.left, context);
	context.push(` = `);
	genNode(node.right, context);
}
function genSequenceExpression(node, context) {
	context.push(`(`);
	genNodeList(node.expressions, context);
	context.push(`)`);
}
function genReturnStatement({ returns }, context) {
	context.push(`return `);
	if (isArray$3(returns)) genNodeListAsArray(returns, context);
	else genNode(returns, context);
}
//#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$1(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)) {
	if (!context.prefixIdentifiers || !node.content.trim()) return node;
	const { inline, bindingMetadata } = context;
	const rewriteIdentifier = (raw, parent, id) => {
		const type = hasOwn(bindingMetadata, raw) && bindingMetadata[raw];
		if (inline) {
			const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
			const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
			const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
			const isNewExpression = parent && isInNewExpression(parentStack);
			const wrapWithUnref = (raw) => {
				const wrapped = `${context.helperString(UNREF)}(${raw})`;
				return isNewExpression ? `(${wrapped})` : wrapped;
			};
			if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) return raw;
			else if (type === "setup-ref") return `${raw}.value`;
			else if (type === "setup-maybe-ref") return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : wrapWithUnref(raw);
			else if (type === "setup-let") {
				if (isAssignmentLVal) {
					const { right: rVal, operator } = parent;
					const rExpString = stringifyExpression(processExpression(createSimpleExpression(rawExp.slice(rVal.start - 1, rVal.end - 1), false), context, false, false, knownIds));
					return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
				} else if (isUpdateArg) {
					id.start = parent.start;
					id.end = parent.end;
					const { prefix: isPrefix, operator } = parent;
					const prefix = isPrefix ? operator : ``;
					const postfix = isPrefix ? `` : operator;
					return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
				} else if (isDestructureAssignment) return raw;
				else return wrapWithUnref(raw);
			} else if (type === "props") return genPropsAccessExp(raw);
			else if (type === "props-aliased") return genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
		} else if (type && type.startsWith("setup") || type === "literal-const") return `$setup.${raw}`;
		else if (type === "props-aliased") return `$props['${bindingMetadata.__propsAliases[raw]}']`;
		else if (type) return `$${type}.${raw}`;
		return `_ctx.${raw}`;
	};
	const rawExp = node.content;
	let ast = node.ast;
	if (ast === false) return node;
	if (ast === null || !ast && isSimpleIdentifier(rawExp)) {
		const isScopeVarReference = context.identifiers[rawExp];
		const isAllowedGlobal = isGloballyAllowed(rawExp);
		const isLiteral = isLiteralWhitelisted(rawExp);
		if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {
			if (isConst(bindingMetadata[rawExp])) node.constType = 1;
			node.content = rewriteIdentifier(rawExp);
		} else if (!isScopeVarReference) {
			if (isLiteral) node.constType = 3;
			else node.constType = 2;
		}
		return node;
	}
	if (!ast) {
		const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
		try {
			ast = (0, import_lib.parseExpression)(source, {
				sourceType: "module",
				plugins: context.expressionPlugins
			});
		} catch (e) {
			context.onError(createCompilerError(46, node.loc, void 0, e.message));
			return node;
		}
	}
	const ids = [];
	const parentStack = [];
	const knownIds = Object.create(context.identifiers);
	walkIdentifiers(ast, (node, parent, _, isReferenced, isLocal) => {
		if (isStaticPropertyKey(node, parent)) return;
		const needPrefix = isReferenced && canPrefix$1(node);
		if (needPrefix && !isLocal) {
			if (isStaticProperty(parent) && parent.shorthand) node.prefix = `${node.name}: `;
			node.name = rewriteIdentifier(node.name, parent, node);
			ids.push(node);
		} else {
			if (!(needPrefix && isLocal) && (!parent || parent.type !== "CallExpression" && parent.type !== "NewExpression" && parent.type !== "MemberExpression")) node.isConstant = true;
			ids.push(node);
		}
	}, true, parentStack, knownIds);
	const children = [];
	ids.sort((a, b) => a.start - b.start);
	ids.forEach((id, i) => {
		const start = id.start - 1;
		const end = id.end - 1;
		const last = ids[i - 1];
		const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
		if (leadingText.length || id.prefix) children.push(leadingText + (id.prefix || ``));
		const source = rawExp.slice(start, end);
		children.push(createSimpleExpression(id.name, false, {
			start: advancePositionWithClone(node.loc.start, source, start),
			end: advancePositionWithClone(node.loc.start, source, end),
			source
		}, id.isConstant ? 3 : 0));
		if (i === ids.length - 1 && end < rawExp.length) children.push(rawExp.slice(end));
	});
	let ret;
	if (children.length) {
		ret = createCompoundExpression(children, node.loc);
		ret.ast = ast;
	} else {
		ret = node;
		ret.constType = 3;
	}
	ret.identifiers = Object.keys(knownIds);
	return ret;
}
function canPrefix$1(id) {
	if (isGloballyAllowed(id.name)) return false;
	if (id.name === "require") return false;
	return true;
}
function stringifyExpression(exp) {
	if (isString$1(exp)) return exp;
	else if (exp.type === 4) return exp.content;
	else return exp.children.map(stringifyExpression).join("");
}
function isConst(type) {
	return type === "setup-const" || type === "literal-const";
}
//#endregion
//#region packages/compiler-core/src/transforms/vIf.ts
const transformIf = createStructuralDirectiveTransform$1(/^(?:if|else|else-if)$/, (node, dir, context) => {
	return processIf$1(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$1(node, dir, context, processCodegen) {
	if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
		const loc = dir.exp ? dir.exp.loc : node.loc;
		context.onError(createCompilerError(28, dir.loc));
		dir.exp = createSimpleExpression(`true`, false, loc);
	}
	if (context.prefixIdentifiers && dir.exp) dir.exp = processExpression(dir.exp, context);
	if (dir.name === "if") {
		const branch = createIfBranch$1(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$1(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$1(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$1(node, dir) {
	const isTemplateIf = node.tagType === 3;
	return {
		type: 10,
		loc: node.loc,
		condition: dir.name === "else" ? void 0 : dir.exp,
		children: isTemplateIf && !findDir$1(node, "for") ? node.children : [node],
		userKey: findProp$1(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$1(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$1("for", (node, dir, context) => {
	const { helper, removeHelper } = context;
	return processFor$1(node, dir, context, (forNode) => {
		const renderExp = createCallExpression(helper(RENDER_LIST), [forNode.source]);
		const isTemplate = isTemplateNode(node);
		const memo = findDir$1(node, "memo");
		const keyProp = findProp$1(node, `key`, false, true);
		const isDirKey = keyProp && keyProp.type === 7;
		let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
		const keyProperty = keyExp ? createObjectProperty(`key`, keyExp) : null;
		if (isTemplate && memo) memo.exp = processExpression(memo.exp, context);
		if ((isTemplate || memo) && keyProperty && isDirKey) {
			keyExp = keyProp.exp = keyProperty.value = processExpression(keyProperty.value, context);
			if (memo) context.vForMemoKeyedNodes.add(node);
		}
		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$1(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$1(node, dir, context, processCodegen) {
	if (!dir.exp) {
		context.onError(createCompilerError(31, dir.loc));
		return;
	}
	const parseResult = dir.forParseResult;
	if (!parseResult) {
		context.onError(createCompilerError(32, dir.loc));
		return;
	}
	finalizeForParseResult(parseResult, context);
	const { addIdentifiers, removeIdentifiers, scopes } = context;
	const { source, value, key, index } = parseResult;
	const forNode = {
		type: 11,
		loc: dir.loc,
		source,
		valueAlias: value,
		keyAlias: key,
		objectIndexAlias: index,
		parseResult,
		children: isTemplateNode(node) ? node.children : [node]
	};
	context.replaceNode(forNode);
	scopes.vFor++;
	if (context.prefixIdentifiers) {
		value && addIdentifiers(value);
		key && addIdentifiers(key);
		index && addIdentifiers(index);
	}
	const onExit = processCodegen && processCodegen(forNode);
	return () => {
		scopes.vFor--;
		if (context.prefixIdentifiers) {
			value && removeIdentifiers(value);
			key && removeIdentifiers(key);
			index && removeIdentifiers(index);
		}
		if (onExit) onExit();
	};
}
function finalizeForParseResult(result, context) {
	if (result.finalized) return;
	if (context.prefixIdentifiers) {
		result.source = processExpression(result.source, context);
		if (result.key) result.key = processExpression(result.key, context, true);
		if (result.index) result.index = processExpression(result.index, context, true);
		if (result.value) result.value = processExpression(result.value, context, true);
	}
	result.finalized = true;
}
function createForLoopParams({ value, key, index }, memoArgs = []) {
	return createParamsList([
		value,
		key,
		index,
		...memoArgs
	]);
}
function createParamsList(args) {
	let i = args.length;
	while (i--) if (args[i]) break;
	return args.slice(0, i + 1).map((arg, 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$1(node, "slot");
		if (vSlot) {
			const slotProps = vSlot.exp;
			if (context.prefixIdentifiers) slotProps && context.addIdentifiers(slotProps, "slot");
			context.scopes.vSlot++;
			return () => {
				if (context.prefixIdentifiers) slotProps && context.removeIdentifiers(slotProps);
				context.scopes.vSlot--;
			};
		}
	}
};
const trackVForSlotScopes = (node, context) => {
	let vFor;
	if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir$1(node, "for"))) {
		const result = vFor.forParseResult;
		if (result) {
			finalizeForParseResult(result, context);
			const { value, key, index } = result;
			const { addIdentifiers, removeIdentifiers } = context;
			value && addIdentifiers(value);
			key && addIdentifiers(key);
			index && addIdentifiers(index);
			return () => {
				value && removeIdentifiers(value);
				key && removeIdentifiers(key);
				index && removeIdentifiers(index);
			};
		}
	}
};
const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(props, children, false, true, children.length ? children[0].loc : loc);
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
	context.helper(WITH_CTX);
	const { children, loc } = node;
	const slotsProperties = [];
	const dynamicSlots = [];
	let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
	if (!context.ssr && context.prefixIdentifiers) hasDynamicSlots = node.props.some((prop) => isVSlot(prop) && (hasScopeRef(prop.arg, context.identifiers) || hasScopeRef(prop.exp, context.identifiers))) || children.some((child) => hasScopeRef(child, context.identifiers));
	const onComponentSlot = findDir$1(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$1(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$1(slotElement, "for");
		const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
		let vIf;
		let vElse;
		if (vIf = findDir$1(slotElement, "if")) {
			hasDynamicSlots = true;
			dynamicSlots.push(createConditionalExpression(vIf.exp, buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++), defaultFallback));
		} else if (vElse = findDir$1(slotElement, /^else(?:-if)?$/, true)) {
			let j = i;
			let prev;
			while (j--) {
				prev = children[j];
				if (!isCommentOrWhitespace(prev)) break;
			}
			if (prev && isTemplateNode(prev) && findDir$1(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) => {
			return createObjectProperty(`default`, buildSlotFn(props, void 0, children, loc));
		};
		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$1 = (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$2(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$1(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$1(tag);
	const isProp = findProp$1(node, "is", false, true);
	if (isProp) {
		if (isExplicitDynamic || false) {
			let exp;
			if (isProp.type === 6) exp = isProp.value && createSimpleExpression(isProp.value.content, true);
			else {
				exp = isProp.exp;
				if (!exp) {
					exp = createSimpleExpression(`is`, false, isProp.arg.loc);
					exp = isProp.exp = processExpression(exp, context);
				}
			}
			if (exp) return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [exp]);
		} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) tag = isProp.value.content.slice(4);
	}
	const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
	if (builtIn) {
		if (!ssr) context.helper(builtIn);
		return builtIn;
	}
	{
		const fromScope = resolveSlotScopeReference(tag, context);
		if (fromScope) return fromScope;
		const dotIndex = tag.indexOf(".");
		if (dotIndex > 0) {
			const ns = resolveSlotScopeReference(tag.slice(0, dotIndex), context);
			if (ns) return ns + tag.slice(dotIndex);
		}
	}
	{
		const fromSetup = resolveSetupReference$1(tag, context);
		if (fromSetup) return fromSetup;
		const dotIndex = tag.indexOf(".");
		if (dotIndex > 0) {
			const ns = resolveSetupReference$1(tag.slice(0, dotIndex), context);
			if (ns) return ns + tag.slice(dotIndex);
		}
	}
	if (context.selfName && capitalize(camelize(tag)) === context.selfName) {
		context.helper(RESOLVE_COMPONENT);
		context.components.add(tag + `__self`);
		return toValidAssetId(tag, `component`);
	}
	context.helper(RESOLVE_COMPONENT);
	context.components.add(tag);
	return toValidAssetId(tag, `component`);
}
function resolveSlotScopeReference(name, context) {
	const camelName = camelize(name);
	const PascalName = capitalize(camelName);
	const isInSlotScope = (reference) => context.isSlotScopeIdentifier(reference);
	if (isInSlotScope(name)) return name;
	if (isInSlotScope(camelName)) return camelName;
	if (isInSlotScope(PascalName)) return PascalName;
}
function resolveSetupReference$1(name, context) {
	const bindings = context.bindingMetadata;
	if (!bindings || bindings.__isScriptSetup === false) return;
	const camelName = camelize(name);
	const PascalName = capitalize(camelName);
	const checkType = (type) => {
		if (bindings[name] === type) return name;
		if (bindings[camelName] === type) return camelName;
		if (bindings[PascalName] === type) return PascalName;
	};
	const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const");
	if (fromConst) return context.inline ? fromConst : `$setup[${JSON.stringify(fromConst)}]`;
	const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref");
	if (fromMaybeRef) return context.inline ? `${context.helperString(UNREF)}(${fromMaybeRef})` : `$setup[${JSON.stringify(fromMaybeRef)}]`;
	const fromProps = checkType("props");
	if (fromProps) return `${context.helperString(UNREF)}(${context.inline ? "__props" : "$props"}[${JSON.stringify(fromProps)}])`;
}
function buildProps$1(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$1(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$1(name)) hasHydrationEventBinding = true;
			if (isEventHandler && isReservedProp$1(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 (value && context.inline) {
					const binding = context.bindingMetadata[value.content];
					if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") {
						isStatic = false;
						properties.push(createObjectProperty(createSimpleExpression("ref_key", true), createSimpleExpression(value.content, true, value.loc)));
					}
				}
			}
			if (name === "is" && (isComponentTag$1(tag) || value && value.content.startsWith("vue:") || false)) 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$1(tag) || false)) 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) {
						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$1(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$1(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 {
		const fromSetup = resolveSetupReference$1("v-" + dir.name, context);
		if (fromSetup) dirArgs.push(fromSetup);
		else {
			context.helper(RESOLVE_DIRECTIVE);
			context.directives.add(dir.name);
			dirArgs.push(toValidAssetId(dir.name, `directive`));
		}
	}
	const { loc } = dir;
	if (dir.exp) dirArgs.push(dir.exp);
	if (dir.arg) {
		if (!dir.exp) dirArgs.push(`void 0`);
		dirArgs.push(dir.arg);
	}
	if (Object.keys(dir.modifiers).length) {
		if (!dir.arg) {
			if (!dir.exp) dirArgs.push(`void 0`);
			dirArgs.push(`void 0`);
		}
		const trueExpression = createSimpleExpression(`true`, false, loc);
		dirArgs.push(createObjectExpression(dir.modifiers.map((modifier) => createObjectProperty(modifier, trueExpression)), loc));
	}
	return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props) {
	let propsNamesString = `[`;
	for (let i = 0, l = props.length; i < l; i++) {
		propsNamesString += JSON.stringify(props[i]);
		if (i < l - 1) propsNamesString += ", ";
	}
	return propsNamesString + `]`;
}
function isComponentTag$1(tag) {
	return tag === "component" || tag === "Component";
}
//#endregion
//#region packages/compiler-core/src/transforms/transformSlotOutlet.ts
const transformSlotOutlet$1 = (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);
				slotName = p.exp = processExpression(p.exp, context);
			}
		} 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$1(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$1 = (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$1(exp, context);
		const isInlineStatement = !(isMemberExp || isFnExpression(exp, context));
		const hasMultipleStatements = exp.content.includes(`;`);
		if (context.prefixIdentifiers) {
			isInlineStatement && context.addIdentifiers(`$event`);
			exp = dir.exp = processExpression(exp, context, false, hasMultipleStatements);
			isInlineStatement && context.removeIdentifiers(`$event`);
			shouldCache = context.cacheHandlers && !context.inVOnce && !(exp.type === 4 && exp.constType > 0) && !(isMemberExp && node.tagType === 1) && !hasScopeRef(exp, context.identifiers);
			if (shouldCache && isMemberExp) {
				if (exp.type === 4) exp.content = `${exp.content} && ${exp.content}(...args)`;
				else exp.children = [
					...exp.children,
					` && `,
					...exp.children,
					`(...args)`
				];
			}
		}
		if (isInlineStatement || shouldCache && isMemberExp) exp = createCompoundExpression([
			`${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `\n//@ts-ignore\n` : ``}(...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()) {
		context.onError(createCompilerError(34, loc));
		return { props: [createObjectProperty(arg, createSimpleExpression("", true, loc))] };
	}
	if (arg.type !== 4) {
		arg.children.unshift(`(`);
		arg.children.push(`) || ""`);
	} else if (!arg.isStatic) arg.content = arg.content ? `${arg.content} || ""` : `""`;
	if (modifiers.some((mod) => mod.content === "camel")) {
		if (arg.type === 4) {
			if (arg.isStatic) arg.content = 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$1 = (node, context) => {
	if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) return () => {
		const children = node.children;
		let currentContainer = void 0;
		let hasText = false;
		for (let i = 0; i < children.length; i++) {
			const child = children[i];
			if (isText$1(child)) {
				hasText = true;
				for (let j = i + 1; j < children.length; j++) {
					const next = children[j];
					if (isText$1(next)) {
						if (!currentContainer) currentContainer = children[i] = createCompoundExpression([child], child.loc);
						currentContainer.children.push(` + `, next);
						children.splice(j, 1);
						j--;
					} else {
						currentContainer = void 0;
						break;
					}
				}
			}
		}
		if (!hasText || children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && !node.props.find((p) => p.type === 7 && !context.directiveTransforms[p.name]) && true)) return;
		for (let i = 0; i < children.length; i++) {
			const child = children[i];
			if (isText$1(child) || child.type === 8) {
				const callArgs = [];
				if (child.type !== 2 || child.content !== " ") callArgs.push(child);
				if (!context.ssr && getConstantType(child, context) === 0) callArgs.push(`1 /* ${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$2 = /* @__PURE__ */ new WeakSet();
const transformOnce = (node, context) => {
	if (node.type === 1 && findDir$1(node, "once", true)) {
		if (seen$2.has(node) || context.inVOnce || context.inSSR) return;
		seen$2.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$1 = (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();
	}
	const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
	if (!expString.trim() || !isMemberExpression$1(exp, context) && !maybeRef) {
		context.onError(createCompilerError(42, exp.loc));
		return createTransformProps();
	}
	if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {
		context.onError(createCompilerError(43, exp.loc));
		return createTransformProps();
	}
	const propName = arg ? arg : createSimpleExpression("modelValue", true);
	const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(["\"onUpdate:\" + ", arg]) : `onUpdate:modelValue`;
	let assignmentExp;
	const eventArg = context.isTS ? `($event: any)` : `$event`;
	if (maybeRef) {
		if (bindingType === "setup-ref") assignmentExp = createCompoundExpression([
			`${eventArg} => ((`,
			createSimpleExpression(rawExp, false, exp.loc),
			`).value = $event)`
		]);
		else {
			const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`;
			assignmentExp = createCompoundExpression([
				`${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,
				createSimpleExpression(rawExp, false, exp.loc),
				`).value = $event : ${altAssignment})`
			]);
		}
	} else assignmentExp = createCompoundExpression([
		`${eventArg} => ((`,
		exp,
		`) = $event)`
	]);
	const props = [createObjectProperty(propName, dir.exp), createObjectProperty(eventName, assignmentExp)];
	if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) props[1].value = context.cache(props[1].value);
	if (dir.modifiers.length && node.tagType === 1) {
		const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
		const modifiersKey = arg ? isStaticExp(arg) ? 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/transforms/vMemo.ts
const seen$1 = /* @__PURE__ */ new WeakSet();
const transformMemo = (node, context) => {
	if (node.type === 1) {
		const dir = findDir$1(node, "memo");
		if (!dir || seen$1.has(node) || context.inSSR) return;
		seen$1.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 || false) && 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$1(prefixIdentifiers) {
	return [[
		transformVBindShorthand,
		transformOnce,
		transformIf,
		transformMemo,
		transformFor,
		...[],
		...prefixIdentifiers ? [trackVForSlotScopes, transformExpression] : [],
		transformSlotOutlet$1,
		transformElement$1,
		trackSlotScopes,
		transformText$1
	], {
		on: transformOn$1,
		bind: transformBind,
		model: transformModel$1
	}];
}
function baseCompile(source, options = {}) {
	const onError = options.onError || defaultOnError;
	const isModuleMode = options.mode === "module";
	/* v8 ignore stop */
	const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
	if (!prefixIdentifiers && options.cacheHandlers) onError(createCompilerError(50));
	if (options.scopeId && !isModuleMode) onError(createCompilerError(51));
	const resolvedOptions = extend({}, options, { prefixIdentifiers });
	const ast = isString$1(source) ? baseParse(source, resolvedOptions) : source;
	const [nodeTransforms, directiveTransforms] = getBaseTransformPreset$1(prefixIdentifiers);
	if (options.isTS) {
		const { expressionPlugins } = options;
		if (!expressionPlugins || !expressionPlugins.includes("typescript")) options.expressionPlugins = [...expressionPlugins || [], "typescript"];
	}
	transform$1(ast, extend({}, resolvedOptions, {
		nodeTransforms: [...nodeTransforms, ...options.nodeTransforms || []],
		directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {})
	}));
	return generate$1(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/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: void 0,
	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$1 = (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$1 = (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 = (dir, node, context) => {
	const baseResult = transformModel$1(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$1(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$1(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 (isEventOptionModifier(modifier)) eventOptionModifiers.push(modifier);
		else {
			const keyString = isString$1(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 = (dir, node, context) => {
	return transformOn$1(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$1 = (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$1(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/stringifyStatic.ts
/**
* This module is Node-only.
*/
/**
* Regex for replacing placeholders for embedded constant variables
* (e.g. import URL string constants generated by compiler-sfc)
*/
const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
/**
* Turn eligible hoisted static trees into stringified static nodes, e.g.
*
* ```js
* const _hoisted_1 = createStaticVNode(`<div class="foo">bar</div>`)
* ```
*
* A single static vnode can contain stringified content for **multiple**
* consecutive nodes (element and plain text), called a "chunk".
* `@vue/runtime-dom` will create the content via innerHTML in a hidden
* container element and insert all the nodes in place. The call must also
* provide the number of nodes contained in the chunk so that during hydration
* we can know how many nodes the static vnode should adopt.
*
* The optimization scans a children list that contains hoisted nodes, and
* tries to find the largest chunk of consecutive hoisted nodes before running
* into a non-hoisted node or the end of the list. A chunk is then converted
* into a single static vnode and replaces the hoisted expression of the first
* node in the chunk. Other nodes in the chunk are considered "merged" and
* therefore removed from both the hoist list and the children array.
*
* This optimization is only performed in Node.js.
*/
const stringifyStatic = (children, context, parent) => {
	if (context.scopes.vSlot > 0) return;
	const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray$3(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
	let nc = 0;
	let ec = 0;
	const currentChunk = [];
	const stringifyCurrentChunk = (currentIndex) => {
		if (nc >= 20 || ec >= 5) {
			const staticCall = createCallExpression(context.helper(CREATE_STATIC), [JSON.stringify(currentChunk.map((node) => stringifyNode(node, context)).join("")).replace(expReplaceRE, `" + $1 + "`), String(currentChunk.length)]);
			const deleteCount = currentChunk.length - 1;
			if (isParentCached) children.splice(currentIndex - currentChunk.length, currentChunk.length, staticCall);
			else {
				currentChunk[0].codegenNode.value = staticCall;
				if (currentChunk.length > 1) {
					children.splice(currentIndex - currentChunk.length + 1, deleteCount);
					const cacheIndex = context.cached.indexOf(currentChunk[currentChunk.length - 1].codegenNode);
					if (cacheIndex > -1) {
						for (let i = cacheIndex; i < context.cached.length; i++) {
							const c = context.cached[i];
							if (c) c.index -= deleteCount;
						}
						context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
					}
				}
			}
			return deleteCount;
		}
		return 0;
	};
	let i = 0;
	for (; i < children.length; i++) {
		const child = children[i];
		if (isParentCached || getCachedNode(child)) {
			const result = analyzeNode(child);
			if (result) {
				nc += result[0];
				ec += result[1];
				currentChunk.push(child);
				continue;
			}
		}
		i -= stringifyCurrentChunk(i);
		nc = 0;
		ec = 0;
		currentChunk.length = 0;
	}
	stringifyCurrentChunk(i);
};
const getCachedNode = (node) => {
	if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) return node.codegenNode;
};
const dataAriaRE = /^(?:data|aria)-/;
const isStringifiableAttr = (name, ns) => {
	return (ns === 0 ? isKnownHtmlAttr(name) : ns === 1 ? isKnownSvgAttr(name) : ns === 2 ? isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
};
const isNonStringifiable = /*@__PURE__*/ makeMap(`caption,thead,tr,th,tbody,td,tfoot,colgroup,col`);
/**
* for a cached node, analyze it and return:
* - false: bailed (contains non-stringifiable props or runtime constant)
* - [nc, ec] where
*   - nc is the number of nodes inside
*   - ec is the number of element with bindings inside
*/
function analyzeNode(node) {
	if (node.type === 1 && isNonStringifiable(node.tag)) return false;
	if (node.type === 1 && findDir$1(node, "once", true)) return false;
	if (node.type === 12) return [1, 0];
	let nc = 1;
	let ec = node.props.length > 0 ? 1 : 0;
	let bailed = false;
	const bail = () => {
		bailed = true;
		return false;
	};
	function walk(node) {
		const isOptionTag = node.tag === "option" && node.ns === 0;
		for (let i = 0; i < node.props.length; i++) {
			const p = node.props[i];
			if (p.type === 6 && !isStringifiableAttr(p.name, node.ns)) return bail();
			if (p.type === 7 && p.name === "bind") {
				if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node.ns))) return bail();
				if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) return bail();
				if (isOptionTag && isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) return bail();
			}
		}
		for (let i = 0; i < node.children.length; i++) {
			nc++;
			const child = node.children[i];
			if (child.type === 1) {
				if (child.props.length > 0) ec++;
				walk(child);
				if (bailed) return false;
			}
		}
		return true;
	}
	return walk(node) ? [nc, ec] : false;
}
function stringifyNode(node, context) {
	if (isString$1(node)) return node;
	if (isSymbol(node)) return ``;
	switch (node.type) {
		case 1: return stringifyElement(node, context);
		case 2: return escapeHtml(node.content);
		case 3: return `<!--${escapeHtml(node.content)}-->`;
		case 5: return escapeHtml(toDisplayString(evaluateConstant(node.content)));
		case 8: return escapeHtml(evaluateConstant(node));
		case 12: return stringifyNode(node.content, context);
		default: return "";
	}
}
function stringifyElement(node, context) {
	let res = `<${node.tag}`;
	let innerHTML = "";
	for (let i = 0; i < node.props.length; i++) {
		const p = node.props[i];
		if (p.type === 6) {
			res += ` ${p.name}`;
			if (p.value) res += `="${escapeHtml(p.value.content)}"`;
		} else if (p.type === 7) {
			if (p.name === "bind") {
				const exp = p.exp;
				if (exp.content[0] === "_") {
					res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
					continue;
				}
				if ((isBooleanAttr(p.arg.content) || p.arg.content === "hidden") && exp.content === "false") continue;
				let evaluated = evaluateConstant(exp);
				if (evaluated != null) {
					const arg = p.arg && p.arg.content;
					if (arg === "hidden" && typeof evaluated === "number" && !includeBooleanAttr(evaluated)) continue;
					if (arg === "class") evaluated = normalizeClass(evaluated);
					else if (arg === "style") evaluated = stringifyStyle(normalizeStyle(evaluated));
					res += ` ${p.arg.content}="${escapeHtml(evaluated)}"`;
				}
			} else if (p.name === "html") innerHTML = evaluateConstant(p.exp);
			else if (p.name === "text") innerHTML = escapeHtml(toDisplayString(evaluateConstant(p.exp)));
		}
	}
	if (context.scopeId) res += ` ${context.scopeId}`;
	res += `>`;
	if (innerHTML) res += innerHTML;
	else for (let i = 0; i < node.children.length; i++) res += stringifyNode(node.children[i], context);
	if (!isVoidTag(node.tag)) res += `</${node.tag}>`;
	return res;
}
function evaluateConstant(exp) {
	if (exp.type === 4) return new Function(`return (${exp.content})`)();
	else {
		let res = ``;
		exp.children.forEach((c) => {
			if (isString$1(c) || isSymbol(c)) return;
			if (c.type === 2) res += c.content;
			else if (c.type === 5) res += toDisplayString(evaluateConstant(c.content));
			else res += evaluateConstant(c);
		});
		return res;
	}
}
//#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
var src_exports$2 = /* @__PURE__ */ __exportAll({
	BASE_TRANSITION: () => BASE_TRANSITION,
	BindingTypes: () => BindingTypes,
	CAMELIZE: () => CAMELIZE,
	CAPITALIZE: () => CAPITALIZE,
	CREATE_BLOCK: () => CREATE_BLOCK,
	CREATE_COMMENT: () => CREATE_COMMENT,
	CREATE_ELEMENT_BLOCK: () => CREATE_ELEMENT_BLOCK,
	CREATE_ELEMENT_VNODE: () => CREATE_ELEMENT_VNODE,
	CREATE_SLOTS: () => CREATE_SLOTS,
	CREATE_STATIC: () => CREATE_STATIC,
	CREATE_TEXT: () => CREATE_TEXT,
	CREATE_VNODE: () => CREATE_VNODE,
	CompilerDeprecationTypes: () => CompilerDeprecationTypes,
	ConstantTypes: () => ConstantTypes,
	DOMDirectiveTransforms: () => DOMDirectiveTransforms,
	DOMErrorCodes: () => DOMErrorCodes,
	DOMErrorMessages: () => DOMErrorMessages,
	DOMNodeTransforms: () => DOMNodeTransforms,
	ElementTypes: () => ElementTypes,
	ErrorCodes: () => ErrorCodes,
	FRAGMENT: () => FRAGMENT,
	GUARD_REACTIVE_PROPS: () => GUARD_REACTIVE_PROPS,
	IS_MEMO_SAME: () => IS_MEMO_SAME,
	IS_REF: () => IS_REF,
	KEEP_ALIVE: () => KEEP_ALIVE,
	MERGE_PROPS: () => MERGE_PROPS,
	MemberExpLexState: () => MemberExpLexState,
	NORMALIZE_CLASS: () => NORMALIZE_CLASS,
	NORMALIZE_PROPS: () => NORMALIZE_PROPS,
	NORMALIZE_STYLE: () => NORMALIZE_STYLE,
	NewlineType: () => NewlineType,
	NodeTypes: () => NodeTypes,
	OPEN_BLOCK: () => OPEN_BLOCK,
	POP_SCOPE_ID: () => POP_SCOPE_ID,
	PUSH_SCOPE_ID: () => PUSH_SCOPE_ID,
	RENDER_LIST: () => RENDER_LIST,
	RENDER_SLOT: () => RENDER_SLOT,
	RESOLVE_COMPONENT: () => RESOLVE_COMPONENT,
	RESOLVE_DIRECTIVE: () => RESOLVE_DIRECTIVE,
	RESOLVE_DYNAMIC_COMPONENT: () => RESOLVE_DYNAMIC_COMPONENT,
	RESOLVE_FILTER: () => RESOLVE_FILTER,
	SET_BLOCK_TRACKING: () => SET_BLOCK_TRACKING,
	SUSPENSE: () => SUSPENSE,
	TELEPORT: () => TELEPORT,
	TO_DISPLAY_STRING: () => TO_DISPLAY_STRING,
	TO_HANDLERS: () => TO_HANDLERS,
	TO_HANDLER_KEY: () => TO_HANDLER_KEY,
	TRANSITION: () => TRANSITION,
	TRANSITION_GROUP: () => TRANSITION_GROUP,
	TS_NODE_TYPES: () => TS_NODE_TYPES,
	UNREF: () => UNREF,
	V_MODEL_CHECKBOX: () => V_MODEL_CHECKBOX,
	V_MODEL_DYNAMIC: () => V_MODEL_DYNAMIC,
	V_MODEL_RADIO: () => V_MODEL_RADIO,
	V_MODEL_SELECT: () => V_MODEL_SELECT,
	V_MODEL_TEXT: () => V_MODEL_TEXT,
	V_ON_WITH_KEYS: () => V_ON_WITH_KEYS,
	V_ON_WITH_MODIFIERS: () => V_ON_WITH_MODIFIERS,
	V_SHOW: () => V_SHOW,
	WITH_CTX: () => WITH_CTX,
	WITH_DIRECTIVES: () => WITH_DIRECTIVES,
	WITH_MEMO: () => WITH_MEMO,
	advancePositionWithClone: () => advancePositionWithClone,
	advancePositionWithMutation: () => advancePositionWithMutation,
	assert: () => assert,
	baseCompile: () => baseCompile,
	baseParse: () => baseParse,
	buildDirectiveArgs: () => buildDirectiveArgs,
	buildProps: () => buildProps$1,
	buildSlots: () => buildSlots,
	checkCompatEnabled: () => checkCompatEnabled,
	compile: () => compile$2,
	convertToBlock: () => convertToBlock,
	createArrayExpression: () => createArrayExpression,
	createAssignmentExpression: () => createAssignmentExpression,
	createBlockStatement: () => createBlockStatement,
	createCacheExpression: () => createCacheExpression,
	createCallExpression: () => createCallExpression,
	createCompilerError: () => createCompilerError,
	createCompoundExpression: () => createCompoundExpression,
	createConditionalExpression: () => createConditionalExpression,
	createDOMCompilerError: () => createDOMCompilerError,
	createForLoopParams: () => createForLoopParams,
	createFunctionExpression: () => createFunctionExpression,
	createIfStatement: () => createIfStatement,
	createInterpolation: () => createInterpolation,
	createObjectExpression: () => createObjectExpression,
	createObjectProperty: () => createObjectProperty,
	createReturnStatement: () => createReturnStatement,
	createRoot: () => createRoot,
	createSequenceExpression: () => createSequenceExpression,
	createSimpleExpression: () => createSimpleExpression,
	createStructuralDirectiveTransform: () => createStructuralDirectiveTransform$1,
	createTemplateLiteral: () => createTemplateLiteral,
	createTransformContext: () => createTransformContext,
	createVNodeCall: () => createVNodeCall,
	defaultOnError: () => defaultOnError,
	defaultOnWarn: () => defaultOnWarn,
	errorMessages: () => errorMessages$1,
	extractIdentifiers: () => extractIdentifiers,
	filterNonCommentChildren: () => filterNonCommentChildren,
	findDir: () => findDir$1,
	findProp: () => findProp$1,
	forAliasRE: () => forAliasRE,
	generate: () => generate$1,
	generateCodeFrame: () => generateCodeFrame,
	getBaseTransformPreset: () => getBaseTransformPreset$1,
	getConstantType: () => getConstantType,
	getMemoedVNodeCall: () => getMemoedVNodeCall,
	getSelfName: () => getSelfName,
	getVNodeBlockHelper: () => getVNodeBlockHelper,
	getVNodeHelper: () => getVNodeHelper,
	hasDynamicKeyVBind: () => hasDynamicKeyVBind,
	hasScopeRef: () => hasScopeRef,
	hasSingleChild: () => hasSingleChild,
	helperNameMap: () => helperNameMap,
	injectProp: () => injectProp,
	isAllWhitespace: () => isAllWhitespace,
	isCommentOrWhitespace: () => isCommentOrWhitespace,
	isConstantNode: () => isConstantNode,
	isCoreComponent: () => isCoreComponent,
	isFnExpression: () => isFnExpression,
	isFnExpressionBrowser: () => isFnExpressionBrowser,
	isFnExpressionNode: () => isFnExpressionNode,
	isFunctionType: () => isFunctionType,
	isInDestructureAssignment: () => isInDestructureAssignment,
	isInNewExpression: () => isInNewExpression,
	isKeyboardEvent: () => isKeyboardEvent,
	isLiteralWhitelisted: () => isLiteralWhitelisted,
	isMemberExpression: () => isMemberExpression$1,
	isMemberExpressionBrowser: () => isMemberExpressionBrowser,
	isMemberExpressionNode: () => isMemberExpressionNode,
	isReferencedIdentifier: () => isReferencedIdentifier,
	isSimpleIdentifier: () => isSimpleIdentifier,
	isSingleIfBlock: () => isSingleIfBlock,
	isSlotOutlet: () => isSlotOutlet,
	isStaticArgOf: () => isStaticArgOf,
	isStaticExp: () => isStaticExp,
	isStaticNode: () => isStaticNode,
	isStaticProperty: () => isStaticProperty,
	isStaticPropertyKey: () => isStaticPropertyKey,
	isTemplateNode: () => isTemplateNode,
	isText: () => isText$1,
	isVPre: () => isVPre,
	isVSlot: () => isVSlot,
	isValidHTMLNesting: () => isValidHTMLNesting,
	isWhitespaceText: () => isWhitespaceText,
	locStub: () => locStub,
	noopDirectiveTransform: () => noopDirectiveTransform,
	parse: () => parse$5,
	parserOptions: () => parserOptions,
	postTransformTransition: () => postTransformTransition,
	processExpression: () => processExpression,
	processFor: () => processFor$1,
	processIf: () => processIf$1,
	processSlotOutlet: () => processSlotOutlet,
	registerRuntimeHelpers: () => registerRuntimeHelpers,
	resolveComponentType: () => resolveComponentType,
	resolveModifiers: () => resolveModifiers,
	stringifyExpression: () => stringifyExpression,
	toValidAssetId: () => toValidAssetId,
	trackSlotScopes: () => trackSlotScopes,
	trackVForSlotScopes: () => trackVForSlotScopes,
	transform: () => transform$1,
	transformBind: () => transformBind,
	transformElement: () => transformElement$1,
	transformExpression: () => transformExpression,
	transformModel: () => transformModel$1,
	transformOn: () => transformOn$1,
	transformStyle: () => transformStyle,
	transformVBindShorthand: () => transformVBindShorthand,
	traverseNode: () => traverseNode,
	unwrapTSNode: () => unwrapTSNode,
	validFirstIdentCharRE: () => validFirstIdentCharRE,
	walkBlockDeclarations: () => walkBlockDeclarations,
	walkFunctionParams: () => walkFunctionParams,
	walkIdentifiers: () => walkIdentifiers,
	warnDeprecation: () => warnDeprecation
});
const DOMNodeTransforms = [transformStyle, ...[transformTransition$1, validateHtmlNesting]];
const DOMDirectiveTransforms = {
	cloak: noopDirectiveTransform,
	html: transformVHtml$1,
	text: transformVText$1,
	model: transformModel,
	on: transformOn,
	show: transformShow
};
function compile$2(src, options = {}) {
	return baseCompile(src, extend({}, parserOptions, options, {
		nodeTransforms: [
			ignoreSideEffectTags,
			...DOMNodeTransforms,
			...options.nodeTransforms || []
		],
		directiveTransforms: extend({}, DOMDirectiveTransforms, options.directiveTransforms || {}),
		transformHoist: stringifyStatic
	}));
}
function parse$5(template, options = {}) {
	return baseParse(template, extend({}, parserOptions, options));
}
//#endregion
//#region packages/compiler-sfc/src/style/cssVars.ts
var import_hash_sum = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	function pad(hash, len) {
		while (hash.length < len) hash = "0" + hash;
		return hash;
	}
	function fold(hash, text) {
		var i;
		var chr;
		var len;
		if (text.length === 0) return hash;
		for (i = 0, len = text.length; i < len; i++) {
			chr = text.charCodeAt(i);
			hash = (hash << 5) - hash + chr;
			hash |= 0;
		}
		return hash < 0 ? hash * -2 : hash;
	}
	function foldObject(hash, o, seen) {
		return Object.keys(o).sort().reduce(foldKey, hash);
		function foldKey(hash, key) {
			return foldValue(hash, o[key], key, seen);
		}
	}
	function foldValue(input, value, key, seen) {
		var hash = fold(fold(fold(input, key), toString(value)), typeof value);
		if (value === null) return fold(hash, "null");
		if (value === void 0) return fold(hash, "undefined");
		if (typeof value === "object" || typeof value === "function") {
			if (seen.indexOf(value) !== -1) return fold(hash, "[Circular]" + key);
			seen.push(value);
			var objHash = foldObject(hash, value, seen);
			if (!("valueOf" in value) || typeof value.valueOf !== "function") return objHash;
			try {
				return fold(objHash, String(value.valueOf()));
			} catch (err) {
				return fold(objHash, "[valueOf exception]" + (err.stack || err.message));
			}
		}
		return fold(hash, value.toString());
	}
	function toString(o) {
		return Object.prototype.toString.call(o);
	}
	function sum(o) {
		return pad(foldValue(0, o, "", []).toString(16), 8);
	}
	module.exports = sum;
})))());
const CSS_VARS_HELPER = `useCssVars`;
function getCssVarsHelper(vapor) {
	return vapor ? `useVaporCssVars` : CSS_VARS_HELPER;
}
function genCssVarsFromList(vars, id, isProd, isSSR = false) {
	return `{\n  ${vars.map((key) => `"${isSSR ? `:--` : ``}${genVarName$1(id, key, isProd, isSSR)}": (${key})`).join(",\n  ")}\n}`;
}
function genVarName$1(id, raw, isProd, isSSR = false) {
	if (isProd) return (0, import_hash_sum.default)(id + raw).replace(/^\d/, (r) => `v${r}`);
	else return `${id}-${getEscapedCssVarName(raw, isSSR)}`;
}
function normalizeExpression(exp) {
	exp = exp.trim();
	if (exp[0] === `'` && exp[exp.length - 1] === `'` || exp[0] === `"` && exp[exp.length - 1] === `"`) return exp.slice(1, -1);
	return exp;
}
const vBindRE = /v-bind\s*\(/g;
function parseCssVars(sfc) {
	const vars = [];
	sfc.styles.forEach((style) => {
		let match;
		const content = stripComments(style.content);
		while (match = vBindRE.exec(content)) {
			const start = match.index + match[0].length;
			const end = lexBinding(content, start);
			if (end !== null) {
				const variable = normalizeExpression(content.slice(start, end));
				if (!vars.includes(variable)) vars.push(variable);
			}
		}
	});
	return vars;
}
const cssSpecialRE = /[/"'\\(]/g;
function stripComments(content) {
	const len = content.length;
	let out = "";
	let last = 0;
	let i = 0;
	cssSpecialRE.lastIndex = 0;
	while (cssSpecialRE.test(content)) {
		i = cssSpecialRE.lastIndex - 1;
		const c = content.charCodeAt(i);
		if (c === 47) {
			const next = content.charCodeAt(i + 1);
			if (next === 42) {
				out += content.slice(last, i);
				const end = content.indexOf("*/", i + 2);
				i = last = end === -1 ? len : end + 2;
			} else if (next === 47) {
				out += content.slice(last, i);
				i += 2;
				while (i < len && !isNewline(content.charCodeAt(i))) i++;
				last = i;
			} else i++;
		} else if (c === 34 || c === 39) i = skipString(content, i + 1, c);
		else if (c === 92) i += 2;
		else if (isUrlFunction(content, i)) i = skipUrl(content, i + 1);
		else i++;
		cssSpecialRE.lastIndex = i;
	}
	return last === 0 ? content : out + content.slice(last);
}
function skipString(s, i, quote) {
	while (i < s.length) {
		const c = s.charCodeAt(i);
		if (c === quote) return i + 1;
		if (isNewline(c)) return i;
		if (c === 92) i += s.charCodeAt(i + 1) === 13 && s.charCodeAt(i + 2) === 10 ? 3 : 2;
		else i++;
	}
	return i;
}
function isUrlFunction(s, i) {
	const prev = s.charCodeAt(i - 4);
	return (s.charCodeAt(i - 3) | 32) === 117 && (s.charCodeAt(i - 2) | 32) === 114 && (s.charCodeAt(i - 1) | 32) === 108 && prev !== 92 && !isIdentChar(prev);
}
function skipUrl(s, i) {
	while (isWhitespace(s.charCodeAt(i))) i++;
	const c = s.charCodeAt(i);
	if (c === 34 || c === 39) return i;
	while (i < s.length) {
		const c = s.charCodeAt(i);
		if (c === 41) return i + 1;
		i += c === 92 ? 2 : 1;
	}
	return i;
}
function isIdentChar(c) {
	return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45 || c === 95 || c >= 128;
}
function isNewline(c) {
	return c === 10 || c === 13;
}
function isWhitespace(c) {
	return c === 32 || c === 9 || c === 12 || isNewline(c);
}
function lexBinding(content, start) {
	let state = 0;
	let parenDepth = 0;
	for (let i = start; i < content.length; i++) {
		const char = content.charAt(i);
		switch (state) {
			case 0:
				if (char === `'`) state = 1;
				else if (char === `"`) state = 2;
				else if (char === `(`) parenDepth++;
				else if (char === `)`) {
					if (parenDepth > 0) parenDepth--;
					else return i;
				}
				break;
			case 1:
				if (char === `'`) state = 0;
				break;
			case 2: if (char === `"`) state = 0;
		}
	}
	return null;
}
const cssVarsPlugin = (opts) => {
	const { id, isProd } = opts;
	return {
		postcssPlugin: "vue-sfc-vars",
		Declaration(decl) {
			const value = decl.value;
			if (vBindRE.test(value)) {
				vBindRE.lastIndex = 0;
				let transformed = "";
				let lastIndex = 0;
				let match;
				while (match = vBindRE.exec(value)) {
					const start = match.index + match[0].length;
					const end = lexBinding(value, start);
					if (end !== null) {
						const variable = normalizeExpression(value.slice(start, end));
						transformed += value.slice(lastIndex, match.index) + `var(--${genVarName$1(id, variable, isProd)})`;
						lastIndex = end + 1;
					}
				}
				decl.value = transformed + value.slice(lastIndex);
			}
		}
	};
};
cssVarsPlugin.postcss = true;
function genCssVarsCode(vars, bindings, id, isProd, vapor) {
	const transformed = processExpression(createSimpleExpression(genCssVarsFromList(vars, id, isProd), false), createTransformContext(createRoot([]), {
		prefixIdentifiers: true,
		inline: true,
		bindingMetadata: bindings.__isScriptSetup === false ? void 0 : bindings
	}));
	const transformedString = transformed.type === 4 ? transformed.content : transformed.children.map((c) => {
		return typeof c === "string" ? c : c.content;
	}).join("");
	return `_${getCssVarsHelper(vapor)}(_ctx => (${transformedString}))`;
}
function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd, defaultVar) {
	return `\nimport { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'\nconst __injectCSSVars__ = () => {\n${genCssVarsCode(cssVars, bindings, id, isProd)}}\nconst __setup__ = ${defaultVar}.setup\n${defaultVar}.setup = __setup__\n  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }\n  : __injectCSSVars__\n`;
}
//#endregion
//#region \0polyfill-node.process.js
function defaultSetTimout() {
	throw new Error("setTimeout has not been defined");
}
function defaultClearTimeout() {
	throw new Error("clearTimeout has not been defined");
}
function runTimeout(fun) {
	if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0);
	if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
		cachedSetTimeout = setTimeout;
		return setTimeout(fun, 0);
	}
	try {
		return cachedSetTimeout(fun, 0);
	} catch (e) {
		try {
			return cachedSetTimeout.call(null, fun, 0);
		} catch (e) {
			return cachedSetTimeout.call(this, fun, 0);
		}
	}
}
function runClearTimeout(marker) {
	if (cachedClearTimeout === clearTimeout) return clearTimeout(marker);
	if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
		cachedClearTimeout = clearTimeout;
		return clearTimeout(marker);
	}
	try {
		return cachedClearTimeout(marker);
	} catch (e) {
		try {
			return cachedClearTimeout.call(null, marker);
		} catch (e) {
			return cachedClearTimeout.call(this, marker);
		}
	}
}
function cleanUpNextTick() {
	if (!draining || !currentQueue) return;
	draining = false;
	if (currentQueue.length) queue = currentQueue.concat(queue);
	else queueIndex = -1;
	if (queue.length) drainQueue();
}
function drainQueue() {
	if (draining) return;
	var timeout = runTimeout(cleanUpNextTick);
	draining = true;
	var len = queue.length;
	while (len) {
		currentQueue = queue;
		queue = [];
		while (++queueIndex < len) if (currentQueue) currentQueue[queueIndex].run();
		queueIndex = -1;
		len = queue.length;
	}
	currentQueue = null;
	draining = false;
	runClearTimeout(timeout);
}
function nextTick(fun) {
	var args = new Array(arguments.length - 1);
	if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i];
	queue.push(new Item(fun, args));
	if (queue.length === 1 && !draining) runTimeout(drainQueue);
}
function Item(fun, array) {
	this.fun = fun;
	this.array = array;
}
function noop() {}
function binding(name) {
	throw new Error("process.binding is not supported");
}
function cwd() {
	return "/";
}
function chdir(dir) {
	throw new Error("process.chdir is not supported");
}
function umask() {
	return 0;
}
function hrtime(previousTimestamp) {
	var clocktime = performanceNow.call(performance) * .001;
	var seconds = Math.floor(clocktime);
	var nanoseconds = Math.floor(clocktime % 1 * 1e9);
	if (previousTimestamp) {
		seconds = seconds - previousTimestamp[0];
		nanoseconds = nanoseconds - previousTimestamp[1];
		if (nanoseconds < 0) {
			seconds--;
			nanoseconds += 1e9;
		}
	}
	return [seconds, nanoseconds];
}
function uptime() {
	return (/* @__PURE__ */ new Date() - startTime) / 1e3;
}
var cachedSetTimeout, cachedClearTimeout, queue, draining, currentQueue, queueIndex, title, platform, env, argv, versions, release, config, on, addListener, once, off, removeListener, removeAllListeners, emit, performance, performanceNow, startTime, browser$1;
var init__polyfill_node_process = __esmMin((() => {
	init__polyfill_node_global();
	cachedSetTimeout = defaultSetTimout;
	cachedClearTimeout = defaultClearTimeout;
	if (typeof _polyfill_node_global_default.setTimeout === "function") cachedSetTimeout = setTimeout;
	if (typeof _polyfill_node_global_default.clearTimeout === "function") cachedClearTimeout = clearTimeout;
	queue = [];
	draining = false;
	queueIndex = -1;
	Item.prototype.run = function() {
		this.fun.apply(null, this.array);
	};
	title = "browser";
	platform = "browser";
	env = {};
	argv = [];
	versions = {};
	release = {};
	config = {};
	on = noop;
	addListener = noop;
	once = noop;
	off = noop;
	removeListener = noop;
	removeAllListeners = noop;
	emit = noop;
	performance = _polyfill_node_global_default.performance || {};
	performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
		return (/* @__PURE__ */ new Date()).getTime();
	};
	startTime = /* @__PURE__ */ new Date();
	browser$1 = {
		nextTick,
		title,
		browser: true,
		env,
		argv,
		version: "",
		versions,
		on,
		addListener,
		once,
		off,
		removeListener,
		removeAllListeners,
		emit,
		binding,
		cwd,
		chdir,
		umask,
		hrtime,
		platform,
		release,
		config,
		uptime
	};
}));
//#endregion
//#region packages/compiler-sfc/src/cache.ts
function createCache(max = 500) {
	return /* @__PURE__ */ new Map();
}
//#endregion
//#region packages/compiler-sfc/src/template/resolveTemplateAST.ts
function resolveTemplateAST(inAST, options) {
	if (!(inAST === null || inAST === void 0 ? void 0 : inAST.transformed)) return inAST;
	const { compiler = src_exports$2, compilerOptions, ssr, onError } = options;
	return createRoot((ssr ? src_exports$2 : compiler).parse(inAST.source, _objectSpread2(_objectSpread2({ prefixIdentifiers: true }, compilerOptions), {}, {
		parseMode: "sfc",
		onError
	})).children.find((node) => node.type === 1 && node.tag === "template").children, inAST.source);
}
//#endregion
//#region packages/compiler-sfc/src/script/importUsageCheck.ts
/**
* Check if an identifier is used in the SFC's template.
* - 1.used to determine the properties that should be included in the object returned from setup()
*   when not using inline mode.
* - 2.check whether the built-in properties such as $attrs, $slots, $emit are used in the template
*/
function isUsedInTemplate(identifier, sfc, options) {
	return resolveTemplateUsedIdentifiers(sfc, options).has(identifier);
}
const templateAnalysisCache = createCache();
function resolveTemplateVModelIdentifiers(sfc, options) {
	return resolveTemplateAnalysisResult(sfc, false, options).vModelIds;
}
function resolveTemplateUsedIdentifiers(sfc, options) {
	return resolveTemplateAnalysisResult(sfc, true, options).usedIds;
}
function resolveTemplateAnalysisResult(sfc, collectUsedIds = true, options) {
	const { content, ast } = sfc.template;
	const cached = templateAnalysisCache.get(content);
	if (cached && (!collectUsedIds || cached.usedIds)) return cached;
	const ids = collectUsedIds ? /* @__PURE__ */ new Set() : void 0;
	const vModelIds = /* @__PURE__ */ new Set();
	resolveTemplateAST(ast, {
		compiler: options === null || options === void 0 ? void 0 : options.compiler,
		compilerOptions: options === null || options === void 0 ? void 0 : options.compilerOptions,
		ssr: options === null || options === void 0 ? void 0 : options.ssr,
		onError: () => {}
	}).children.forEach(walk);
	function walk(node) {
		switch (node.type) {
			case 1:
				let tag = node.tag;
				if (tag.includes(".")) tag = tag.split(".")[0].trim();
				if (!parserOptions.isNativeTag(tag) && !parserOptions.isBuiltInComponent(tag)) {
					if (ids) {
						ids.add(camelize(tag));
						ids.add(capitalize(camelize(tag)));
					}
				}
				for (let i = 0; i < node.props.length; i++) {
					var _prop$value;
					const prop = node.props[i];
					if (prop.type === 7) {
						if (ids) {
							if (!isBuiltInDirective(prop.name)) ids.add(`v${capitalize(camelize(prop.name))}`);
						}
						if (prop.name === "model") {
							const exp = prop.exp;
							if (exp && exp.type === 4) {
								const expString = exp.content.trim();
								if (isSimpleIdentifier(expString) && expString !== "undefined") vModelIds.add(expString);
							}
						}
						if (ids && prop.arg && !prop.arg.isStatic) extractIdentifiers$1(ids, prop.arg);
						if (ids) {
							if (prop.name === "for") extractIdentifiers$1(ids, prop.forParseResult.source);
							else if (prop.exp) extractIdentifiers$1(ids, prop.exp);
							else if (prop.name === "bind" && !prop.exp) ids.add(camelize(prop.arg.content));
						}
					}
					if (ids && prop.type === 6 && prop.name === "ref" && ((_prop$value = prop.value) === null || _prop$value === void 0 ? void 0 : _prop$value.content)) ids.add(prop.value.content);
				}
				node.children.forEach(walk);
				break;
			case 5: if (ids) extractIdentifiers$1(ids, node.content);
		}
	}
	const result = {
		usedIds: ids,
		vModelIds
	};
	templateAnalysisCache.set(content, result);
	return result;
}
function extractIdentifiers$1(ids, node) {
	if (node.ast) walkIdentifiers(node.ast, (n) => ids.add(n.name));
	else if (node.ast === null) ids.add(node.content);
}
//#endregion
//#region packages/compiler-sfc/src/parse.ts
init_objectSpread2();
const DEFAULT_FILENAME = "anonymous.vue";
const parseCache$1 = createCache();
function parse(source, options = {}) {
	var _options$compiler;
	const sourceKey = genCacheKey(source, _objectSpread2(_objectSpread2({}, options), {}, { compiler: { parse: (_options$compiler = options.compiler) === null || _options$compiler === void 0 ? void 0 : _options$compiler.parse } }));
	const cache = parseCache$1.get(sourceKey);
	if (cache) return cache;
	const { sourceMap = true, filename = DEFAULT_FILENAME, sourceRoot = "", pad = false, ignoreEmpty = true, compiler = src_exports$2, templateParseOptions = {} } = options;
	const descriptor = {
		filename,
		source,
		template: null,
		script: null,
		scriptSetup: null,
		styles: [],
		customBlocks: [],
		cssVars: [],
		slotted: false,
		vapor: false,
		shouldForceReload: (prevImports) => hmrShouldReload(prevImports, descriptor)
	};
	const errors = [];
	compiler.parse(source, _objectSpread2(_objectSpread2({
		parseMode: "sfc",
		prefixIdentifiers: true
	}, templateParseOptions), {}, { onError: (e) => {
		errors.push(e);
	} })).children.forEach((node) => {
		if (node.type !== 1) return;
		if (ignoreEmpty && node.tag !== "template" && isEmpty(node) && !hasAttr(node, "src")) {
			descriptor.vapor || (descriptor.vapor = hasAttr(node, "vapor"));
			return;
		}
		switch (node.tag) {
			case "template":
				if (!descriptor.template) {
					const templateBlock = descriptor.template = createBlock(node, source, false);
					descriptor.vapor || (descriptor.vapor = !!templateBlock.attrs.vapor);
					if (!templateBlock.attrs.src) templateBlock.ast = createRoot(node.children, source);
					if (templateBlock.attrs.functional) {
						const err = /* @__PURE__ */ new SyntaxError("<template functional> is no longer supported in Vue 3, since functional components no longer have significant performance difference from stateful ones. Just use a normal <template> instead.");
						err.loc = node.props.find((p) => p.type === 6 && p.name === "functional").loc;
						errors.push(err);
					}
				} else errors.push(createDuplicateBlockError(node));
				break;
			case "script":
				const scriptBlock = createBlock(node, source, pad);
				descriptor.vapor || (descriptor.vapor = !!scriptBlock.attrs.vapor);
				const isSetup = !!(scriptBlock.attrs.setup || scriptBlock.attrs.vapor);
				if (isSetup && !descriptor.scriptSetup) {
					descriptor.scriptSetup = scriptBlock;
					break;
				}
				if (!isSetup && !descriptor.script) {
					descriptor.script = scriptBlock;
					break;
				}
				errors.push(createDuplicateBlockError(node, isSetup));
				break;
			case "style":
				const styleBlock = createBlock(node, source, pad);
				if (styleBlock.attrs.vars) errors.push(/* @__PURE__ */ new SyntaxError("<style vars> has been replaced by a new proposal: https://github.com/vuejs/rfcs/pull/231"));
				descriptor.styles.push(styleBlock);
				break;
			default: descriptor.customBlocks.push(createBlock(node, source, pad));
		}
	});
	if (!descriptor.template && !descriptor.script && !descriptor.scriptSetup) errors.push(/* @__PURE__ */ new SyntaxError(`At least one <template> or <script> is required in a single file component. ${descriptor.filename}`));
	if (descriptor.scriptSetup) {
		if (descriptor.scriptSetup.src) {
			errors.push(/* @__PURE__ */ new SyntaxError("<script setup> cannot use the \"src\" attribute because its syntax will be ambiguous outside of the component."));
			descriptor.scriptSetup = null;
		}
		if (descriptor.script && descriptor.script.src) {
			errors.push(/* @__PURE__ */ new SyntaxError("<script> cannot use the \"src\" attribute when <script setup> is also present because they must be processed together."));
			descriptor.script = null;
		}
	}
	let templateColumnOffset = 0;
	if (descriptor.template && (descriptor.template.lang === "pug" || descriptor.template.lang === "jade")) [descriptor.template.content, templateColumnOffset] = dedent(descriptor.template.content);
	if (sourceMap) {
		const genMap = (block, columnOffset = 0) => {
			if (block && !block.src) block.map = generateSourceMap(filename, source, block.content, sourceRoot, !pad || block.type === "template" ? block.loc.start.line - 1 : 0, columnOffset);
		};
		genMap(descriptor.template, templateColumnOffset);
		genMap(descriptor.script);
		descriptor.styles.forEach((s) => genMap(s));
		descriptor.customBlocks.forEach((s) => genMap(s));
	}
	descriptor.cssVars = parseCssVars(descriptor);
	const slottedRE = /(?:::v-|:)slotted\(/;
	descriptor.slotted = descriptor.styles.some((s) => s.scoped && slottedRE.test(s.content));
	const result = {
		descriptor,
		errors
	};
	parseCache$1.set(sourceKey, result);
	return result;
}
function createDuplicateBlockError(node, isScriptSetup = false) {
	const err = /* @__PURE__ */ new SyntaxError(`Single file component can contain only one <${node.tag}${isScriptSetup ? ` setup` : ``}> element`);
	err.loc = node.loc;
	return err;
}
function createBlock(node, source, pad) {
	const type = node.tag;
	const loc = node.innerLoc;
	const attrs = {};
	const block = {
		type,
		content: source.slice(loc.start.offset, loc.end.offset),
		loc,
		attrs
	};
	if (pad) block.content = padContent(source, block, pad) + block.content;
	node.props.forEach((p) => {
		if (p.type === 6) {
			const name = p.name;
			attrs[name] = p.value ? p.value.content || true : true;
			if (name === "lang") block.lang = p.value && p.value.content;
			else if (name === "src") block.src = p.value && p.value.content;
			else if (type === "style") {
				if (name === "scoped") block.scoped = true;
				else if (name === "module") block.module = attrs[name];
			} else if (type === "script" && name === "setup") block.setup = attrs.setup;
		}
	});
	return block;
}
const splitRE = /\r?\n/g;
const emptyRE = /^(?:\/\/)?\s*$/;
const replaceRE = /./g;
function generateSourceMap(filename, source, generated, sourceRoot, lineOffset, columnOffset) {
	const map = new import_source_map.SourceMapGenerator({
		file: filename.replace(/\\/g, "/"),
		sourceRoot: sourceRoot.replace(/\\/g, "/")
	});
	map.setSourceContent(filename, source);
	map._sources.add(filename);
	generated.split(splitRE).forEach((line, index) => {
		if (!emptyRE.test(line)) {
			const originalLine = index + 1 + lineOffset;
			const generatedLine = index + 1;
			for (let i = 0; i < line.length; i++) if (!/\s/.test(line[i])) map._mappings.add({
				originalLine,
				originalColumn: i + columnOffset,
				generatedLine,
				generatedColumn: i,
				source: filename,
				name: null
			});
		}
	});
	return map.toJSON();
}
function padContent(content, block, pad) {
	content = content.slice(0, block.loc.start.offset);
	if (pad === "space") return content.replace(replaceRE, " ");
	else {
		const offset = content.split(splitRE).length;
		const padChar = block.type === "script" && !block.lang ? "//\n" : "\n";
		return Array(offset).join(padChar);
	}
}
function hasAttr(node, name) {
	return node.props.some((p) => p.type === 6 && p.name === name);
}
/**
* Returns true if the node has no children
* once the empty text nodes (trimmed content) have been filtered out.
*/
function isEmpty(node) {
	for (let i = 0; i < node.children.length; i++) {
		const child = node.children[i];
		if (child.type !== 2 || child.content.trim() !== "") return false;
	}
	return true;
}
/**
* Note: this comparison assumes the prev/next script are already identical,
* and only checks the special case where <script setup lang="ts"> unused import
* pruning result changes due to template changes.
*/
function hmrShouldReload(prevImports, next) {
	if (!next.scriptSetup || next.scriptSetup.lang !== "ts" && next.scriptSetup.lang !== "tsx") return false;
	for (const key in prevImports) if (!prevImports[key].isUsedInTemplate && isUsedInTemplate(key, next)) return true;
	return false;
}
/**
* Dedent a string.
*
* This removes any whitespace that is common to all lines in the string from
* each line in the string.
*/
function dedent(s) {
	const lines = s.split("\n");
	const minIndent = lines.reduce(function(minIndent, line) {
		var _line$match;
		if (line.trim() === "") return minIndent;
		const indent = ((_line$match = line.match(/^\s*/)) === null || _line$match === void 0 || (_line$match = _line$match[0]) === null || _line$match === void 0 ? void 0 : _line$match.length) || 0;
		return Math.min(indent, minIndent);
	}, Infinity);
	if (minIndent === 0) return [s, minIndent];
	return [lines.map(function(line) {
		return line.slice(minIndent);
	}).join("\n"), minIndent];
}
//#endregion
//#region \0polyfill-node.path.js
var _polyfill_node_path_exports = /* @__PURE__ */ __exportAll({
	basename: () => basename,
	default: () => _polyfill_node_path_default,
	delimiter: () => ":",
	dirname: () => dirname,
	extname: () => extname,
	isAbsolute: () => isAbsolute,
	join: () => join,
	normalize: () => normalize$1,
	relative: () => relative,
	resolve: () => resolve,
	sep: () => "/"
});
function normalizeArray(parts, allowAboveRoot) {
	var up = 0;
	for (var i = parts.length - 1; i >= 0; i--) {
		var last = parts[i];
		if (last === ".") parts.splice(i, 1);
		else if (last === "..") {
			parts.splice(i, 1);
			up++;
		} else if (up) {
			parts.splice(i, 1);
			up--;
		}
	}
	if (allowAboveRoot) for (; up--;) parts.unshift("..");
	return parts;
}
function resolve() {
	var resolvedPath = "", resolvedAbsolute = false;
	for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
		var path = i >= 0 ? arguments[i] : "/";
		if (typeof path !== "string") throw new TypeError("Arguments to path.resolve must be strings");
		else if (!path) continue;
		resolvedPath = path + "/" + resolvedPath;
		resolvedAbsolute = path.charAt(0) === "/";
	}
	resolvedPath = normalizeArray(filter(resolvedPath.split("/"), function(p) {
		return !!p;
	}), !resolvedAbsolute).join("/");
	return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
}
function normalize$1(path) {
	var isPathAbsolute = isAbsolute(path), trailingSlash = substr(path, -1) === "/";
	path = normalizeArray(filter(path.split("/"), function(p) {
		return !!p;
	}), !isPathAbsolute).join("/");
	if (!path && !isPathAbsolute) path = ".";
	if (path && trailingSlash) path += "/";
	return (isPathAbsolute ? "/" : "") + path;
}
function isAbsolute(path) {
	return path.charAt(0) === "/";
}
function join() {
	return normalize$1(filter(Array.prototype.slice.call(arguments, 0), function(p, index) {
		if (typeof p !== "string") throw new TypeError("Arguments to path.join must be strings");
		return p;
	}).join("/"));
}
function relative(from, to) {
	from = resolve(from).substr(1);
	to = resolve(to).substr(1);
	function trim(arr) {
		var start = 0;
		for (; start < arr.length; start++) if (arr[start] !== "") break;
		var end = arr.length - 1;
		for (; end >= 0; end--) if (arr[end] !== "") break;
		if (start > end) return [];
		return arr.slice(start, end - start + 1);
	}
	var fromParts = trim(from.split("/"));
	var toParts = trim(to.split("/"));
	var length = Math.min(fromParts.length, toParts.length);
	var samePartsLength = length;
	for (var i = 0; i < length; i++) if (fromParts[i] !== toParts[i]) {
		samePartsLength = i;
		break;
	}
	var outputParts = [];
	for (var i = samePartsLength; i < fromParts.length; i++) outputParts.push("..");
	outputParts = outputParts.concat(toParts.slice(samePartsLength));
	return outputParts.join("/");
}
function dirname(path) {
	var result = splitPath(path), root = result[0], dir = result[1];
	if (!root && !dir) return ".";
	if (dir) dir = dir.substr(0, dir.length - 1);
	return root + dir;
}
function basename(path, ext) {
	var f = splitPath(path)[2];
	if (ext && f.substr(-1 * ext.length) === ext) f = f.substr(0, f.length - ext.length);
	return f;
}
function extname(path) {
	return splitPath(path)[3];
}
function filter(xs, f) {
	if (xs.filter) return xs.filter(f);
	var res = [];
	for (var i = 0; i < xs.length; i++) if (f(xs[i], i, xs)) res.push(xs[i]);
	return res;
}
var splitPathRe, splitPath, _polyfill_node_path_default, substr;
var init__polyfill_node_path = __esmMin((() => {
	splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
	splitPath = function(filename) {
		return splitPathRe.exec(filename).slice(1);
	};
	_polyfill_node_path_default = {
		extname,
		basename,
		dirname,
		sep: "/",
		delimiter: ":",
		relative,
		join,
		isAbsolute,
		normalize: normalize$1,
		resolve
	};
	substr = "ab".substr(-1) === "b" ? function(str, start, len) {
		return str.substr(start, len);
	} : function(str, start, len) {
		if (start < 0) start = str.length + start;
		return str.substr(start, len);
	};
}));
//#endregion
//#region \0polyfill-node.punycode.js
/*! https://mths.be/punycode v1.4.1 by @mathias */
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
	throw new RangeError(errors[type]);
}
/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function map$1(array, fn) {
	var length = array.length;
	var result = [];
	while (length--) result[length] = fn(array[length]);
	return result;
}
/**
* A simple `Array#map`-like wrapper to work with domain name strings or email
* addresses.
* @private
* @param {String} domain The domain name or email address.
* @param {Function} callback The function that gets called for every
* character.
* @returns {Array} A new string of characters returned by the callback
* function.
*/
function mapDomain(string, fn) {
	var parts = string.split("@");
	var result = "";
	if (parts.length > 1) {
		result = parts[0] + "@";
		string = parts[1];
	}
	string = string.replace(regexSeparators, ".");
	var encoded = map$1(string.split("."), fn).join(".");
	return result + encoded;
}
/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
* @see `punycode.ucs2.encode`
* @see <https://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode.ucs2
* @name decode
* @param {String} string The Unicode input string (UCS-2).
* @returns {Array} The new array of code points.
*/
function ucs2decode(string) {
	var output = [], counter = 0, length = string.length, value, extra;
	while (counter < length) {
		value = string.charCodeAt(counter++);
		if (value >= 55296 && value <= 56319 && counter < length) {
			extra = string.charCodeAt(counter++);
			if ((extra & 64512) == 56320) output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
			else {
				output.push(value);
				counter--;
			}
		} else output.push(value);
	}
	return output;
}
/**
* Converts a digit/integer into a basic code point.
* @see `basicToDigit()`
* @private
* @param {Number} digit The numeric value of a basic code point.
* @returns {Number} The basic code point whose value (when used for
* representing integers) is `digit`, which needs to be in the range
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
* used; else, the lowercase form is used. The behavior is undefined
* if `flag` is non-zero and `digit` has no uppercase form.
*/
function digitToBasic(digit, flag) {
	return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}
/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* https://tools.ietf.org/html/rfc3492#section-3.4
* @private
*/
function adapt(delta, numPoints, firstTime) {
	var k = 0;
	delta = firstTime ? floor(delta / damp) : delta >> 1;
	delta += floor(delta / numPoints);
	for (; delta > baseMinusTMin * tMax >> 1; k += base) delta = floor(delta / baseMinusTMin);
	return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
}
/**
* Converts a string of Unicode symbols (e.g. a domain name label) to a
* Punycode string of ASCII-only symbols.
* @memberOf punycode
* @param {String} input The string of Unicode symbols.
* @returns {String} The resulting Punycode string of ASCII-only symbols.
*/
function encode$1(input) {
	var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
	input = ucs2decode(input);
	inputLength = input.length;
	n = initialN;
	delta = 0;
	bias = initialBias;
	for (j = 0; j < inputLength; ++j) {
		currentValue = input[j];
		if (currentValue < 128) output.push(stringFromCharCode(currentValue));
	}
	handledCPCount = basicLength = output.length;
	if (basicLength) output.push(delimiter);
	while (handledCPCount < inputLength) {
		for (m = maxInt, j = 0; j < inputLength; ++j) {
			currentValue = input[j];
			if (currentValue >= n && currentValue < m) m = currentValue;
		}
		handledCPCountPlusOne = handledCPCount + 1;
		if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) error("overflow");
		delta += (m - n) * handledCPCountPlusOne;
		n = m;
		for (j = 0; j < inputLength; ++j) {
			currentValue = input[j];
			if (currentValue < n && ++delta > maxInt) error("overflow");
			if (currentValue == n) {
				for (q = delta, k = base;; k += base) {
					t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
					if (q < t) break;
					qMinusT = q - t;
					baseMinusT = base - t;
					output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
					q = floor(qMinusT / baseMinusT);
				}
				output.push(stringFromCharCode(digitToBasic(q, 0)));
				bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
				delta = 0;
				++handledCPCount;
			}
		}
		++delta;
		++n;
	}
	return output.join("");
}
/**
* Converts a Unicode string representing a domain name or an email address to
* Punycode. Only the non-ASCII parts of the domain name will be converted,
* i.e. it doesn't matter if you call it with a domain that's already in
* ASCII.
* @memberOf punycode
* @param {String} input The domain name or email address to convert, as a
* Unicode string.
* @returns {String} The Punycode representation of the given domain name or
* email address.
*/
function toASCII(input) {
	return mapDomain(input, function(string) {
		return regexNonASCII.test(string) ? "xn--" + encode$1(string) : string;
	});
}
var maxInt, base, tMin, tMax, skew, damp, initialBias, initialN, delimiter, regexNonASCII, regexSeparators, errors, baseMinusTMin, floor, stringFromCharCode;
var init__polyfill_node_punycode = __esmMin((() => {
	maxInt = 2147483647;
	base = 36;
	tMin = 1;
	tMax = 26;
	skew = 38;
	damp = 700;
	initialBias = 72;
	initialN = 128;
	delimiter = "-";
	regexNonASCII = /[^\x20-\x7E]/;
	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
	errors = {
		"overflow": "Overflow: input needs wider integers to process",
		"not-basic": "Illegal input >= 0x80 (not a basic code point)",
		"invalid-input": "Invalid input"
	};
	baseMinusTMin = base - tMin;
	floor = Math.floor;
	stringFromCharCode = String.fromCharCode;
}));
//#endregion
//#region \0polyfill-node.util.js
/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
function inspect(obj, opts) {
	var ctx = {
		seen: [],
		stylize: stylizeNoColor
	};
	if (arguments.length >= 3) ctx.depth = arguments[2];
	if (arguments.length >= 4) ctx.colors = arguments[3];
	if (isBoolean(opts)) ctx.showHidden = opts;
	else if (opts) _extend(ctx, opts);
	if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
	if (isUndefined(ctx.depth)) ctx.depth = 2;
	if (isUndefined(ctx.colors)) ctx.colors = false;
	if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
	if (ctx.colors) ctx.stylize = stylizeWithColor;
	return formatValue(ctx, obj, ctx.depth);
}
function stylizeWithColor(str, styleType) {
	var style = inspect.styles[styleType];
	if (style) return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
	else return str;
}
function stylizeNoColor(str, styleType) {
	return str;
}
function arrayToHash(array) {
	var hash = {};
	array.forEach(function(val, idx) {
		hash[val] = true;
	});
	return hash;
}
function formatValue(ctx, value, recurseTimes) {
	if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== inspect && !(value.constructor && value.constructor.prototype === value)) {
		var ret = value.inspect(recurseTimes, ctx);
		if (!isString(ret)) ret = formatValue(ctx, ret, recurseTimes);
		return ret;
	}
	var primitive = formatPrimitive(ctx, value);
	if (primitive) return primitive;
	var keys = Object.keys(value);
	var visibleKeys = arrayToHash(keys);
	if (ctx.showHidden) keys = Object.getOwnPropertyNames(value);
	if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) return formatError(value);
	if (keys.length === 0) {
		if (isFunction(value)) {
			var name = value.name ? ": " + value.name : "";
			return ctx.stylize("[Function" + name + "]", "special");
		}
		if (isRegExp(value)) return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
		if (isDate(value)) return ctx.stylize(Date.prototype.toString.call(value), "date");
		if (isError(value)) return formatError(value);
	}
	var base = "", array = false, braces = ["{", "}"];
	if (isArray$1(value)) {
		array = true;
		braces = ["[", "]"];
	}
	if (isFunction(value)) base = " [Function" + (value.name ? ": " + value.name : "") + "]";
	if (isRegExp(value)) base = " " + RegExp.prototype.toString.call(value);
	if (isDate(value)) base = " " + Date.prototype.toUTCString.call(value);
	if (isError(value)) base = " " + formatError(value);
	if (keys.length === 0 && (!array || value.length == 0)) return braces[0] + base + braces[1];
	if (recurseTimes < 0) {
		if (isRegExp(value)) return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
		else return ctx.stylize("[Object]", "special");
	}
	ctx.seen.push(value);
	var output;
	if (array) output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
	else output = keys.map(function(key) {
		return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
	});
	ctx.seen.pop();
	return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
	if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
	if (isString(value)) {
		var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, "\"") + "'";
		return ctx.stylize(simple, "string");
	}
	if (isNumber(value)) return ctx.stylize("" + value, "number");
	if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
	if (isNull(value)) return ctx.stylize("null", "null");
}
function formatError(value) {
	return "[" + Error.prototype.toString.call(value) + "]";
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
	var output = [];
	for (var i = 0, l = value.length; i < l; ++i) if (hasOwnProperty$2(value, String(i))) output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
	else output.push("");
	keys.forEach(function(key) {
		if (!key.match(/^\d+$/)) output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
	});
	return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
	var name, str, desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
	if (desc.get) {
		if (desc.set) str = ctx.stylize("[Getter/Setter]", "special");
		else str = ctx.stylize("[Getter]", "special");
	} else if (desc.set) str = ctx.stylize("[Setter]", "special");
	if (!hasOwnProperty$2(visibleKeys, key)) name = "[" + key + "]";
	if (!str) {
		if (ctx.seen.indexOf(desc.value) < 0) {
			if (isNull(recurseTimes)) str = formatValue(ctx, desc.value, null);
			else str = formatValue(ctx, desc.value, recurseTimes - 1);
			if (str.indexOf("\n") > -1) {
				if (array) str = str.split("\n").map(function(line) {
					return "  " + line;
				}).join("\n").substr(2);
				else str = "\n" + str.split("\n").map(function(line) {
					return "   " + line;
				}).join("\n");
			}
		} else str = ctx.stylize("[Circular]", "special");
	}
	if (isUndefined(name)) {
		if (array && key.match(/^\d+$/)) return str;
		name = JSON.stringify("" + key);
		if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
			name = name.substr(1, name.length - 2);
			name = ctx.stylize(name, "name");
		} else {
			name = name.replace(/'/g, "\\'").replace(/\\"/g, "\"").replace(/(^"|"$)/g, "'");
			name = ctx.stylize(name, "string");
		}
	}
	return name + ": " + str;
}
function reduceToSingleString(output, base, braces) {
	var numLinesEst = 0;
	if (output.reduce(function(prev, cur) {
		numLinesEst++;
		if (cur.indexOf("\n") >= 0) numLinesEst++;
		return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
	}, 0) > 60) return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
	return braces[0] + base + " " + output.join(", ") + " " + braces[1];
}
function isArray$1(ar) {
	return Array.isArray(ar);
}
function isBoolean(arg) {
	return typeof arg === "boolean";
}
function isNull(arg) {
	return arg === null;
}
function isNullOrUndefined(arg) {
	return arg == null;
}
function isNumber(arg) {
	return typeof arg === "number";
}
function isString(arg) {
	return typeof arg === "string";
}
function isUndefined(arg) {
	return arg === void 0;
}
function isRegExp(re) {
	return isObject$1(re) && objectToString(re) === "[object RegExp]";
}
function isObject$1(arg) {
	return typeof arg === "object" && arg !== null;
}
function isDate(d) {
	return isObject$1(d) && objectToString(d) === "[object Date]";
}
function isError(e) {
	return isObject$1(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
}
function isFunction(arg) {
	return typeof arg === "function";
}
function objectToString(o) {
	return Object.prototype.toString.call(o);
}
function _extend(origin, add) {
	if (!add || !isObject$1(add)) return origin;
	var keys = Object.keys(add);
	var i = keys.length;
	while (i--) origin[keys[i]] = add[keys[i]];
	return origin;
}
function hasOwnProperty$2(obj, prop) {
	return Object.prototype.hasOwnProperty.call(obj, prop);
}
function promisify(original) {
	if (typeof original !== "function") throw new TypeError("The \"original\" argument must be of type Function");
	if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
		var fn = original[kCustomPromisifiedSymbol];
		if (typeof fn !== "function") throw new TypeError("The \"util.promisify.custom\" argument must be of type Function");
		Object.defineProperty(fn, kCustomPromisifiedSymbol, {
			value: fn,
			enumerable: false,
			writable: false,
			configurable: true
		});
		return fn;
	}
	function fn() {
		var promiseResolve, promiseReject;
		var promise = new Promise(function(resolve, reject) {
			promiseResolve = resolve;
			promiseReject = reject;
		});
		var args = [];
		for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
		args.push(function(err, value) {
			if (err) promiseReject(err);
			else promiseResolve(value);
		});
		try {
			original.apply(this, args);
		} catch (err) {
			promiseReject(err);
		}
		return promise;
	}
	Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
	if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
		value: fn,
		enumerable: false,
		writable: false,
		configurable: true
	});
	return Object.defineProperties(fn, getOwnPropertyDescriptors(original));
}
var getOwnPropertyDescriptors, kCustomPromisifiedSymbol;
var init__polyfill_node_util = __esmMin((() => {
	getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(obj) {
		var keys = Object.keys(obj);
		var descriptors = {};
		for (var i = 0; i < keys.length; i++) descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
		return descriptors;
	};
	inspect.colors = {
		"bold": [1, 22],
		"italic": [3, 23],
		"underline": [4, 24],
		"inverse": [7, 27],
		"white": [37, 39],
		"grey": [90, 39],
		"black": [30, 39],
		"blue": [34, 39],
		"cyan": [36, 39],
		"green": [32, 39],
		"magenta": [35, 39],
		"red": [31, 39],
		"yellow": [33, 39]
	};
	inspect.styles = {
		"special": "cyan",
		"number": "yellow",
		"boolean": "yellow",
		"undefined": "grey",
		"null": "bold",
		"string": "green",
		"date": "magenta",
		"regexp": "red"
	};
	kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
	promisify.custom = kCustomPromisifiedSymbol;
}));
//#endregion
//#region \0polyfill-node.querystring.js
function hasOwnProperty$1(obj, prop) {
	return Object.prototype.hasOwnProperty.call(obj, prop);
}
function stringifyPrimitive(v) {
	switch (typeof v) {
		case "string": return v;
		case "boolean": return v ? "true" : "false";
		case "number": return isFinite(v) ? v : "";
		default: return "";
	}
}
function stringify$1(obj, sep, eq, name) {
	sep = sep || "&";
	eq = eq || "=";
	if (obj === null) obj = void 0;
	if (typeof obj === "object") return map(objectKeys(obj), function(k) {
		var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
		if (isArray(obj[k])) return map(obj[k], function(v) {
			return ks + encodeURIComponent(stringifyPrimitive(v));
		}).join(sep);
		else return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
	}).join(sep);
	if (!name) return "";
	return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));
}
function map(xs, f) {
	if (xs.map) return xs.map(f);
	var res = [];
	for (var i = 0; i < xs.length; i++) res.push(f(xs[i], i));
	return res;
}
function parse$4(qs, sep, eq, options) {
	sep = sep || "&";
	eq = eq || "=";
	var obj = {};
	if (typeof qs !== "string" || qs.length === 0) return obj;
	var regexp = /\+/g;
	qs = qs.split(sep);
	var maxKeys = 1e3;
	if (options && typeof options.maxKeys === "number") maxKeys = options.maxKeys;
	var len = qs.length;
	if (maxKeys > 0 && len > maxKeys) len = maxKeys;
	for (var i = 0; i < len; ++i) {
		var x = qs[i].replace(regexp, "%20"), idx = x.indexOf(eq), kstr, vstr, k, v;
		if (idx >= 0) {
			kstr = x.substr(0, idx);
			vstr = x.substr(idx + 1);
		} else {
			kstr = x;
			vstr = "";
		}
		k = decodeURIComponent(kstr);
		v = decodeURIComponent(vstr);
		if (!hasOwnProperty$1(obj, k)) obj[k] = v;
		else if (isArray(obj[k])) obj[k].push(v);
		else obj[k] = [obj[k], v];
	}
	return obj;
}
var isArray, objectKeys;
var init__polyfill_node_querystring = __esmMin((() => {
	isArray = Array.isArray || function(xs) {
		return Object.prototype.toString.call(xs) === "[object Array]";
	};
	objectKeys = Object.keys || function(obj) {
		var res = [];
		for (var key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
		return res;
	};
}));
//#endregion
//#region \0polyfill-node.url.js
var _polyfill_node_url_exports = /* @__PURE__ */ __exportAll({
	URL: () => URL$1,
	URLSearchParams: () => URLSearchParams,
	Url: () => Url,
	default: () => _polyfill_node_url_default,
	fileURLToPath: () => urlFileURLToPath,
	format: () => urlFormat,
	parse: () => urlParse,
	resolve: () => urlResolve,
	resolveObject: () => urlResolveObject
});
function Url() {
	this.protocol = null;
	this.slashes = null;
	this.auth = null;
	this.host = null;
	this.port = null;
	this.hostname = null;
	this.hash = null;
	this.search = null;
	this.query = null;
	this.pathname = null;
	this.path = null;
	this.href = null;
}
function urlParse(url, parseQueryString, slashesDenoteHost) {
	if (url && isObject$1(url) && url instanceof Url) return url;
	var u = new Url();
	u.parse(url, parseQueryString, slashesDenoteHost);
	return u;
}
function parse$3(self, url, parseQueryString, slashesDenoteHost) {
	if (!isString(url)) throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
	var queryIndex = url.indexOf("?"), splitter = queryIndex !== -1 && queryIndex < url.indexOf("#") ? "?" : "#", uSplit = url.split(splitter);
	uSplit[0] = uSplit[0].replace(/\\/g, "/");
	url = uSplit.join(splitter);
	var rest = url;
	rest = rest.trim();
	if (!slashesDenoteHost && url.split("#").length === 1) {
		var simplePath = simplePathPattern.exec(rest);
		if (simplePath) {
			self.path = rest;
			self.href = rest;
			self.pathname = simplePath[1];
			if (simplePath[2]) {
				self.search = simplePath[2];
				if (parseQueryString) self.query = parse$4(self.search.substr(1));
				else self.query = self.search.substr(1);
			} else if (parseQueryString) {
				self.search = "";
				self.query = {};
			}
			return self;
		}
	}
	var proto = protocolPattern.exec(rest);
	if (proto) {
		proto = proto[0];
		var lowerProto = proto.toLowerCase();
		self.protocol = lowerProto;
		rest = rest.substr(proto.length);
	}
	if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
		var slashes = rest.substr(0, 2) === "//";
		if (slashes && !(proto && hostlessProtocol[proto])) {
			rest = rest.substr(2);
			self.slashes = true;
		}
	}
	var i, hec, l, p;
	if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
		var hostEnd = -1;
		for (i = 0; i < hostEndingChars.length; i++) {
			hec = rest.indexOf(hostEndingChars[i]);
			if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) hostEnd = hec;
		}
		var auth, atSign;
		if (hostEnd === -1) atSign = rest.lastIndexOf("@");
		else atSign = rest.lastIndexOf("@", hostEnd);
		if (atSign !== -1) {
			auth = rest.slice(0, atSign);
			rest = rest.slice(atSign + 1);
			self.auth = decodeURIComponent(auth);
		}
		hostEnd = -1;
		for (i = 0; i < nonHostChars.length; i++) {
			hec = rest.indexOf(nonHostChars[i]);
			if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) hostEnd = hec;
		}
		if (hostEnd === -1) hostEnd = rest.length;
		self.host = rest.slice(0, hostEnd);
		rest = rest.slice(hostEnd);
		parseHost(self);
		self.hostname = self.hostname || "";
		var ipv6Hostname = self.hostname[0] === "[" && self.hostname[self.hostname.length - 1] === "]";
		if (!ipv6Hostname) {
			var hostparts = self.hostname.split(/\./);
			for (i = 0, l = hostparts.length; i < l; i++) {
				var part = hostparts[i];
				if (!part) continue;
				if (!part.match(hostnamePartPattern)) {
					var newpart = "";
					for (var j = 0, k = part.length; j < k; j++) if (part.charCodeAt(j) > 127) newpart += "x";
					else newpart += part[j];
					if (!newpart.match(hostnamePartPattern)) {
						var validParts = hostparts.slice(0, i);
						var notHost = hostparts.slice(i + 1);
						var bit = part.match(hostnamePartStart);
						if (bit) {
							validParts.push(bit[1]);
							notHost.unshift(bit[2]);
						}
						if (notHost.length) rest = "/" + notHost.join(".") + rest;
						self.hostname = validParts.join(".");
						break;
					}
				}
			}
		}
		if (self.hostname.length > hostnameMaxLen) self.hostname = "";
		else self.hostname = self.hostname.toLowerCase();
		if (!ipv6Hostname) self.hostname = toASCII(self.hostname);
		p = self.port ? ":" + self.port : "";
		self.host = (self.hostname || "") + p;
		self.href += self.host;
		if (ipv6Hostname) {
			self.hostname = self.hostname.substr(1, self.hostname.length - 2);
			if (rest[0] !== "/") rest = "/" + rest;
		}
	}
	if (!unsafeProtocol[lowerProto]) for (i = 0, l = autoEscape.length; i < l; i++) {
		var ae = autoEscape[i];
		if (rest.indexOf(ae) === -1) continue;
		var esc = encodeURIComponent(ae);
		if (esc === ae) esc = escape(ae);
		rest = rest.split(ae).join(esc);
	}
	var hash = rest.indexOf("#");
	if (hash !== -1) {
		self.hash = rest.substr(hash);
		rest = rest.slice(0, hash);
	}
	var qm = rest.indexOf("?");
	if (qm !== -1) {
		self.search = rest.substr(qm);
		self.query = rest.substr(qm + 1);
		if (parseQueryString) self.query = parse$4(self.query);
		rest = rest.slice(0, qm);
	} else if (parseQueryString) {
		self.search = "";
		self.query = {};
	}
	if (rest) self.pathname = rest;
	if (slashedProtocol[lowerProto] && self.hostname && !self.pathname) self.pathname = "/";
	if (self.pathname || self.search) {
		p = self.pathname || "";
		var s = self.search || "";
		self.path = p + s;
	}
	self.href = format(self);
	return self;
}
function urlFileURLToPath(path) {
	if (typeof path === "string") path = new Url().parse(path);
	else if (!(path instanceof Url)) throw new TypeError("The \"path\" argument must be of type string or an instance of URL. Received type " + typeof path + String(path));
	if (path.protocol !== "file:") throw new TypeError("The URL must be of scheme file");
	return getPathFromURLPosix(path);
}
function getPathFromURLPosix(url) {
	const pathname = url.pathname;
	for (let n = 0; n < pathname.length; n++) if (pathname[n] === "%") {
		const third = pathname.codePointAt(n + 2) | 32;
		if (pathname[n + 1] === "2" && third === 102) throw new TypeError("must not include encoded / characters");
	}
	return decodeURIComponent(pathname);
}
function urlFormat(obj) {
	if (isString(obj)) obj = parse$3({}, obj);
	return format(obj);
}
function format(self) {
	var auth = self.auth || "";
	if (auth) {
		auth = encodeURIComponent(auth);
		auth = auth.replace(/%3A/i, ":");
		auth += "@";
	}
	var protocol = self.protocol || "", pathname = self.pathname || "", hash = self.hash || "", host = false, query = "";
	if (self.host) host = auth + self.host;
	else if (self.hostname) {
		host = auth + (self.hostname.indexOf(":") === -1 ? self.hostname : "[" + this.hostname + "]");
		if (self.port) host += ":" + self.port;
	}
	if (self.query && isObject$1(self.query) && Object.keys(self.query).length) query = stringify$1(self.query);
	var search = self.search || query && "?" + query || "";
	if (protocol && protocol.substr(-1) !== ":") protocol += ":";
	if (self.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
		host = "//" + (host || "");
		if (pathname && pathname.charAt(0) !== "/") pathname = "/" + pathname;
	} else if (!host) host = "";
	if (hash && hash.charAt(0) !== "#") hash = "#" + hash;
	if (search && search.charAt(0) !== "?") search = "?" + search;
	pathname = pathname.replace(/[?#]/g, function(match) {
		return encodeURIComponent(match);
	});
	search = search.replace("#", "%23");
	return protocol + host + pathname + search + hash;
}
function urlResolve(source, relative) {
	return urlParse(source, false, true).resolve(relative);
}
function urlResolveObject(source, relative) {
	if (!source) return relative;
	return urlParse(source, false, true).resolveObject(relative);
}
function parseHost(self) {
	var host = self.host;
	var port = portPattern.exec(host);
	if (port) {
		port = port[0];
		if (port !== ":") self.port = port.substr(1);
		host = host.substr(0, host.length - port.length);
	}
	if (host) self.hostname = host;
}
var URL$1, URLSearchParams, _polyfill_node_url_default, protocolPattern, portPattern, simplePathPattern, unwise, autoEscape, nonHostChars, hostEndingChars, hostnameMaxLen, hostnamePartPattern, hostnamePartStart, unsafeProtocol, hostlessProtocol, slashedProtocol;
var init__polyfill_node_url = __esmMin((() => {
	init__polyfill_node_global();
	init__polyfill_node_punycode();
	init__polyfill_node_util();
	init__polyfill_node_querystring();
	URL$1 = _polyfill_node_global_default.URL;
	URLSearchParams = _polyfill_node_global_default.URLSearchParams;
	_polyfill_node_url_default = {
		parse: urlParse,
		resolve: urlResolve,
		resolveObject: urlResolveObject,
		fileURLToPath: urlFileURLToPath,
		format: urlFormat,
		Url,
		URL: URL$1,
		URLSearchParams
	};
	protocolPattern = /^([a-z0-9.+-]+:)/i;
	portPattern = /:[0-9]*$/;
	simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
	unwise = [
		"{",
		"}",
		"|",
		"\\",
		"^",
		"`"
	].concat([
		"<",
		">",
		"\"",
		"`",
		" ",
		"\r",
		"\n",
		"	"
	]);
	autoEscape = ["'"].concat(unwise);
	nonHostChars = [
		"%",
		"/",
		"?",
		";",
		"#"
	].concat(autoEscape);
	hostEndingChars = [
		"/",
		"?",
		"#"
	];
	hostnameMaxLen = 255;
	hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
	hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
	unsafeProtocol = {
		"javascript": true,
		"javascript:": true
	};
	hostlessProtocol = {
		"javascript": true,
		"javascript:": true
	};
	slashedProtocol = {
		"http": true,
		"https": true,
		"ftp": true,
		"gopher": true,
		"file": true,
		"http:": true,
		"https:": true,
		"ftp:": true,
		"gopher:": true,
		"file:": true
	};
	Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
		return parse$3(this, url, parseQueryString, slashesDenoteHost);
	};
	Url.prototype.format = function() {
		return format(this);
	};
	Url.prototype.resolve = function(relative) {
		return this.resolveObject(urlParse(relative, false, true)).format();
	};
	Url.prototype.resolveObject = function(relative) {
		if (isString(relative)) {
			var rel = new Url();
			rel.parse(relative, false, true);
			relative = rel;
		}
		var result = new Url();
		var tkeys = Object.keys(this);
		for (var tk = 0; tk < tkeys.length; tk++) {
			var tkey = tkeys[tk];
			result[tkey] = this[tkey];
		}
		result.hash = relative.hash;
		if (relative.href === "") {
			result.href = result.format();
			return result;
		}
		if (relative.slashes && !relative.protocol) {
			var rkeys = Object.keys(relative);
			for (var rk = 0; rk < rkeys.length; rk++) {
				var rkey = rkeys[rk];
				if (rkey !== "protocol") result[rkey] = relative[rkey];
			}
			if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) result.path = result.pathname = "/";
			result.href = result.format();
			return result;
		}
		var relPath;
		if (relative.protocol && relative.protocol !== result.protocol) {
			if (!slashedProtocol[relative.protocol]) {
				var keys = Object.keys(relative);
				for (var v = 0; v < keys.length; v++) {
					var k = keys[v];
					result[k] = relative[k];
				}
				result.href = result.format();
				return result;
			}
			result.protocol = relative.protocol;
			if (!relative.host && !hostlessProtocol[relative.protocol]) {
				relPath = (relative.pathname || "").split("/");
				while (relPath.length && !(relative.host = relPath.shift()));
				if (!relative.host) relative.host = "";
				if (!relative.hostname) relative.hostname = "";
				if (relPath[0] !== "") relPath.unshift("");
				if (relPath.length < 2) relPath.unshift("");
				result.pathname = relPath.join("/");
			} else result.pathname = relative.pathname;
			result.search = relative.search;
			result.query = relative.query;
			result.host = relative.host || "";
			result.auth = relative.auth;
			result.hostname = relative.hostname || relative.host;
			result.port = relative.port;
			if (result.pathname || result.search) result.path = (result.pathname || "") + (result.search || "");
			result.slashes = result.slashes || relative.slashes;
			result.href = result.format();
			return result;
		}
		var isSourceAbs = result.pathname && result.pathname.charAt(0) === "/", isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === "/", mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname, removeAllDots = mustEndAbs, srcPath = result.pathname && result.pathname.split("/") || [], psychotic = result.protocol && !slashedProtocol[result.protocol];
		relPath = relative.pathname && relative.pathname.split("/") || [];
		if (psychotic) {
			result.hostname = "";
			result.port = null;
			if (result.host) {
				if (srcPath[0] === "") srcPath[0] = result.host;
				else srcPath.unshift(result.host);
			}
			result.host = "";
			if (relative.protocol) {
				relative.hostname = null;
				relative.port = null;
				if (relative.host) {
					if (relPath[0] === "") relPath[0] = relative.host;
					else relPath.unshift(relative.host);
				}
				relative.host = null;
			}
			mustEndAbs = mustEndAbs && (relPath[0] === "" || srcPath[0] === "");
		}
		var authInHost;
		if (isRelAbs) {
			result.host = relative.host || relative.host === "" ? relative.host : result.host;
			result.hostname = relative.hostname || relative.hostname === "" ? relative.hostname : result.hostname;
			result.search = relative.search;
			result.query = relative.query;
			srcPath = relPath;
		} else if (relPath.length) {
			if (!srcPath) srcPath = [];
			srcPath.pop();
			srcPath = srcPath.concat(relPath);
			result.search = relative.search;
			result.query = relative.query;
		} else if (!isNullOrUndefined(relative.search)) {
			if (psychotic) {
				result.hostname = result.host = srcPath.shift();
				authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
				if (authInHost) {
					result.auth = authInHost.shift();
					result.host = result.hostname = authInHost.shift();
				}
			}
			result.search = relative.search;
			result.query = relative.query;
			if (!isNull(result.pathname) || !isNull(result.search)) result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
			result.href = result.format();
			return result;
		}
		if (!srcPath.length) {
			result.pathname = null;
			if (result.search) result.path = "/" + result.search;
			else result.path = null;
			result.href = result.format();
			return result;
		}
		var last = srcPath.slice(-1)[0];
		var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === "." || last === "..") || last === "";
		var up = 0;
		for (var i = srcPath.length; i >= 0; i--) {
			last = srcPath[i];
			if (last === ".") srcPath.splice(i, 1);
			else if (last === "..") {
				srcPath.splice(i, 1);
				up++;
			} else if (up) {
				srcPath.splice(i, 1);
				up--;
			}
		}
		if (!mustEndAbs && !removeAllDots) for (; up--;) srcPath.unshift("..");
		if (mustEndAbs && srcPath[0] !== "" && (!srcPath[0] || srcPath[0].charAt(0) !== "/")) srcPath.unshift("");
		if (hasTrailingSlash && srcPath.join("/").substr(-1) !== "/") srcPath.push("");
		var isAbsolute = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
		if (psychotic) {
			result.hostname = result.host = isAbsolute ? "" : srcPath.length ? srcPath.shift() : "";
			authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
			if (authInHost) {
				result.auth = authInHost.shift();
				result.host = result.hostname = authInHost.shift();
			}
		}
		mustEndAbs = mustEndAbs || result.host && srcPath.length;
		if (mustEndAbs && !isAbsolute) srcPath.unshift("");
		if (!srcPath.length) {
			result.pathname = null;
			result.path = null;
		} else result.pathname = srcPath.join("/");
		if (!isNull(result.pathname) || !isNull(result.search)) result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
		result.auth = relative.auth || result.auth;
		result.slashes = result.slashes || relative.slashes;
		result.href = result.format();
		return result;
	};
	Url.prototype.parseHost = function() {
		return parseHost(this);
	};
}));
//#endregion
//#region packages/compiler-sfc/src/template/templateUtils.ts
init__polyfill_node_path();
init__polyfill_node_url();
function isRelativeUrl(url) {
	const firstChar = url.charAt(0);
	return firstChar === "." || firstChar === "~" || firstChar === "@" || firstChar === "#";
}
const externalRE = /^(?:https?:)?\/\//;
function isExternalUrl(url) {
	return externalRE.test(url);
}
const dataUrlRE = /^\s*data:/i;
function isDataUrl(url) {
	return dataUrlRE.test(url);
}
function normalizeDecodedImportPath(source) {
	try {
		return decodeURIComponent(source);
	} catch (_unused) {
		return source;
	}
}
/**
* Parses string url into URL object.
*/
function parseUrl(url) {
	if (url.charAt(0) === "~") {
		const secondChar = url.charAt(1);
		url = url.slice(secondChar === "/" ? 2 : 1);
	}
	return parseUriParts(url);
}
/**
* vuejs/component-compiler-utils#22 Support uri fragment in transformed require
* @param urlString - an url as a string
*/
function parseUriParts(urlString) {
	return urlParse(isString$1(urlString) ? urlString : "", false, true);
}
/**
* Whether the current component should be treated as multi-root at the
* component boundary.
*
* This is currently only attached to Vapor components. During Vapor hydration,
* components hydrate while they are being created, so the runtime needs this
* metadata to know whether the current SSR `<!--[--> ... <!--]-->` belongs to
* the component itself and should be consumed before hydrating its children.
*
* The inference is aligned with compile-ssr's ownership semantics: it answers
* whether the component root itself owns an outer fragment wrapper.
*/
function isMultiRoot(template, parserOptions) {
	const preserveComments = (parserOptions === null || parserOptions === void 0 ? void 0 : parserOptions.comments) !== false;
	if (typeof template === "string") return countRootUnits(parse(`<template>${template}</template>`, {
		sourceMap: false,
		ignoreEmpty: false,
		templateParseOptions: parserOptions
	}).descriptor.template.ast, preserveComments) > 1;
	if (isTemplateBlock(template)) return countRootUnits(template.ast, preserveComments) > 1;
	return countRootUnits(template, preserveComments) > 1;
}
function countRootUnits(parent, preserveComments) {
	const { children } = parent;
	let count = 0;
	for (let i = 0; i < children.length; i++) {
		const child = children[i];
		if (isWhitespaceRootText(child)) continue;
		if (isIfBranchStart(child)) {
			count++;
			let lastBranchIndex = i;
			let nextIndex = i + 1;
			while (nextIndex < children.length) {
				let continuationIndex = nextIndex;
				while (continuationIndex < children.length && isIgnorableIfChainSeparator(children[continuationIndex])) continuationIndex++;
				if (continuationIndex < children.length && isIfBranchContinuation(children[continuationIndex])) {
					lastBranchIndex = continuationIndex;
					nextIndex = continuationIndex + 1;
					continue;
				}
				break;
			}
			i = lastBranchIndex;
			continue;
		}
		count += countRootUnit(child, preserveComments);
	}
	return count;
}
function countRootUnit(node, preserveComments) {
	if (node.type !== 1) return node.type === 3 && !preserveComments ? 0 : 1;
	if (hasStructuralDirective(node, "if") || hasStructuralDirective(node, "for")) return 1;
	if (node.tag === "slot" || node.tagType === 1) return 1;
	if (node.tagType === 3) return countRootUnits(node, preserveComments);
	return 1;
}
function hasStructuralDirective(node, name) {
	return !!findDir$1(node, name);
}
function isIfBranchStart(node) {
	return node.type === 1 && hasStructuralDirective(node, "if");
}
function isIfBranchContinuation(node) {
	return node.type === 1 && !!findDir$1(node, /^else(-if)?$/, true);
}
function isWhitespaceRootText(node) {
	return node.type === 2 && !node.content.trim();
}
function isIgnorableIfChainSeparator(node) {
	return isWhitespaceRootText(node) || node.type === 3;
}
function isTemplateBlock(value) {
	return "content" in value && "attrs" in value;
}
//#endregion
//#region packages/compiler-sfc/src/template/transformAssetUrl.ts
init_objectSpread2();
const resourceUrlTagConfig = {
	video: ["src", "poster"],
	source: ["src"],
	img: ["src"]
};
const defaultAssetUrlOptions = {
	base: null,
	includeAbsolute: false,
	tags: _objectSpread2(_objectSpread2({}, resourceUrlTagConfig), {}, {
		image: ["xlink:href", "href"],
		use: ["xlink:href", "href"]
	})
};
const normalizeOptions = (options) => {
	if (Object.keys(options).some((key) => isArray$3(options[key]))) return _objectSpread2(_objectSpread2({}, defaultAssetUrlOptions), {}, { tags: options });
	return _objectSpread2(_objectSpread2({}, defaultAssetUrlOptions), options);
};
const createAssetUrlTransformWithOptions = (options) => {
	return (node, context) => transformAssetUrl(node, context, options);
};
function canTransformHashImport(tag, attrName) {
	var _resourceUrlTagConfig;
	return !!((_resourceUrlTagConfig = resourceUrlTagConfig[tag]) === null || _resourceUrlTagConfig === void 0 ? void 0 : _resourceUrlTagConfig.includes(attrName));
}
/**
* A `@vue/compiler-core` plugin that transforms relative asset urls into
* either imports or absolute urls.
*
* ``` js
* // Before
* createVNode('img', { src: './logo.png' })
*
* // After
* import _imports_0 from './logo.png'
* createVNode('img', { src: _imports_0 })
* ```
*/
const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
	if (node.type === 1) {
		if (!node.props.length) return;
		const tags = options.tags || defaultAssetUrlOptions.tags;
		const attrs = tags[node.tag];
		const wildCardAttrs = tags["*"];
		if (!attrs && !wildCardAttrs) return;
		const assetAttrs = (attrs || []).concat(wildCardAttrs || []);
		node.props.forEach((attr, index) => {
			if (attr.type !== 6 || !assetAttrs.includes(attr.name) || !attr.value) return;
			const urlValue = attr.value.content;
			const isHashOnlyValue = urlValue[0] === "#";
			if (isExternalUrl(urlValue) || isDataUrl(urlValue) || urlValue === "#" || isHashOnlyValue && !canTransformHashImport(node.tag, attr.name) || !options.includeAbsolute && !isRelativeUrl(urlValue)) return;
			const url = parseUrl(urlValue);
			if (options.base && urlValue[0] === ".") {
				const base = parseUrl(options.base);
				const protocol = base.protocol || "";
				const host = base.host ? protocol + "//" + base.host : "";
				const basePath = base.path || "/";
				attr.value.content = host + (_polyfill_node_path_default.posix || _polyfill_node_path_default).join(basePath, url.path + (url.hash || ""));
				return;
			}
			const exp = getImportsExpressionExp(url.path, url.hash, attr.loc, context);
			node.props[index] = {
				type: 7,
				name: "bind",
				arg: createSimpleExpression(attr.name, true, attr.loc),
				exp,
				modifiers: [],
				loc: attr.loc
			};
		});
	}
};
/**
* Resolves or registers an import for the given source path
* @param source - Path to resolve import for
* @param loc - Source location
* @param context - Transform context
* @returns Object containing import name and expression
*/
function resolveOrRegisterImport(source, loc, context) {
	const normalizedSource = normalizeDecodedImportPath(source);
	const existingIndex = context.imports.findIndex((i) => i.path === normalizedSource);
	if (existingIndex > -1) return {
		name: `_imports_${existingIndex}`,
		exp: context.imports[existingIndex].exp
	};
	const name = `_imports_${context.imports.length}`;
	const exp = createSimpleExpression(name, false, loc, 3);
	context.imports.push({
		exp,
		path: normalizedSource
	});
	return {
		name,
		exp
	};
}
/**
* Transforms asset URLs into import expressions or string literals
*/
function getImportsExpressionExp(path, hash, loc, context) {
	if (!path && !hash) return createSimpleExpression(`''`, false, loc, 3);
	if (!path && hash) {
		const { exp } = resolveOrRegisterImport(hash, loc, context);
		return exp;
	}
	if (path && !hash) {
		const { exp } = resolveOrRegisterImport(path, loc, context);
		return exp;
	}
	const { name } = resolveOrRegisterImport(path, loc, context);
	const hashExp = `${name} + '${hash}'`;
	const finalExp = createSimpleExpression(hashExp, false, loc, 3);
	if (!context.hoistStatic) return finalExp;
	const existingHoistIndex = context.hoists.findIndex((h) => {
		return h && h.type === 4 && !h.isStatic && h.content === hashExp;
	});
	if (existingHoistIndex > -1) return createSimpleExpression(`_hoisted_${existingHoistIndex + 1}`, false, loc, 3);
	return context.hoist(finalExp);
}
//#endregion
//#region packages/compiler-sfc/src/template/transformSrcset.ts
init__polyfill_node_path();
const srcsetTags = ["img", "source"];
const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
const createSrcsetTransformWithOptions = (options) => {
	return (node, context) => transformSrcset(node, context, options);
};
const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
	if (node.type === 1) {
		if (srcsetTags.includes(node.tag) && node.props.length) node.props.forEach((attr, index) => {
			if (attr.name === "srcset" && attr.type === 6) {
				if (!attr.value) return;
				const value = attr.value.content;
				if (!value) return;
				const imageCandidates = value.split(",").map((s) => {
					const [url, descriptor] = s.replace(escapedSpaceCharacters, " ").trim().split(" ", 2);
					return {
						url,
						descriptor
					};
				});
				for (let i = 0; i < imageCandidates.length; i++) {
					const { url } = imageCandidates[i];
					if (isDataUrl(url)) {
						imageCandidates[i + 1].url = url + "," + imageCandidates[i + 1].url;
						imageCandidates.splice(i, 1);
					}
				}
				const shouldProcessUrl = (url) => {
					return url && !isExternalUrl(url) && !isDataUrl(url) && (options.includeAbsolute || isRelativeUrl(url));
				};
				if (!imageCandidates.some(({ url }) => shouldProcessUrl(url))) return;
				if (options.base) {
					const base = options.base;
					const set = [];
					let needImportTransform = false;
					imageCandidates.forEach((candidate) => {
						let { url, descriptor } = candidate;
						descriptor = descriptor ? ` ${descriptor}` : ``;
						if (url[0] === ".") {
							candidate.url = (_polyfill_node_path_default.posix || _polyfill_node_path_default).join(base, url);
							set.push(candidate.url + descriptor);
						} else if (shouldProcessUrl(url)) needImportTransform = true;
						else set.push(url + descriptor);
					});
					if (!needImportTransform) {
						attr.value.content = set.join(", ");
						return;
					}
				}
				let content = "";
				imageCandidates.forEach(({ url, descriptor }, index) => {
					if (shouldProcessUrl(url)) {
						const { path, hash } = parseUrl(url);
						const source = path ? path : hash;
						if (source) {
							let exp = "";
							const normalizedSource = normalizeDecodedImportPath(source);
							const existingImportsIndex = context.imports.findIndex((i) => i.path === normalizedSource);
							if (existingImportsIndex > -1) exp = `_imports_${existingImportsIndex}`;
							else {
								exp = `_imports_${context.imports.length}`;
								context.imports.push({
									exp: createSimpleExpression(exp, false, attr.loc, 3),
									path: normalizedSource
								});
							}
							if (path && hash) exp = `${exp} + '${hash}'`;
							content += exp;
						}
					} else content += `"${url}"`;
					const isNotLast = imageCandidates.length - 1 > index;
					if (descriptor) content += ` + ' ${descriptor}${isNotLast ? ", " : ""}'${isNotLast ? " + " : ""}`;
					else if (isNotLast) content += ` + ', ' + `;
				});
				let exp = createSimpleExpression(content, false, attr.loc, 3);
				if (context.hoistStatic) {
					exp = context.hoist(exp);
					exp.constType = 3;
				}
				node.props[index] = {
					type: 7,
					name: "bind",
					arg: createSimpleExpression("srcset", true, attr.loc),
					exp,
					modifiers: [],
					loc: attr.loc
				};
			}
		});
	}
};
//#endregion
//#region packages/compiler-vapor/src/ir/component.ts
const IRDynamicPropsKind = {
	"EXPRESSION": 0,
	"0": "EXPRESSION",
	"ATTRIBUTE": 1,
	"1": "ATTRIBUTE"
};
const IRSlotType = {
	"STATIC": 0,
	"0": "STATIC",
	"DYNAMIC": 1,
	"1": "DYNAMIC",
	"LOOP": 2,
	"2": "LOOP",
	"CONDITIONAL": 3,
	"3": "CONDITIONAL",
	"EXPRESSION": 4,
	"4": "EXPRESSION"
};
//#endregion
//#region packages/compiler-vapor/src/ir/index.ts
const IRNodeTypes = {
	"ROOT": 0,
	"0": "ROOT",
	"BLOCK": 1,
	"1": "BLOCK",
	"SET_BLOCK_KEY": 2,
	"2": "SET_BLOCK_KEY",
	"SET_PROP": 3,
	"3": "SET_PROP",
	"SET_DYNAMIC_PROPS": 4,
	"4": "SET_DYNAMIC_PROPS",
	"SET_TEXT": 5,
	"5": "SET_TEXT",
	"SET_EVENT": 6,
	"6": "SET_EVENT",
	"SET_DYNAMIC_EVENTS": 7,
	"7": "SET_DYNAMIC_EVENTS",
	"SET_HTML": 8,
	"8": "SET_HTML",
	"SET_TEMPLATE_REF": 9,
	"9": "SET_TEMPLATE_REF",
	"INSERT_NODE": 10,
	"10": "INSERT_NODE",
	"CREATE_COMPONENT_NODE": 11,
	"11": "CREATE_COMPONENT_NODE",
	"SLOT_OUTLET_NODE": 12,
	"12": "SLOT_OUTLET_NODE",
	"DIRECTIVE": 13,
	"13": "DIRECTIVE",
	"IF": 14,
	"14": "IF",
	"FOR": 15,
	"15": "FOR",
	"KEY": 16,
	"16": "KEY",
	"GET_TEXT_CHILD": 17,
	"17": "GET_TEXT_CHILD"
};
var TemplateRegistry = class {
	constructor() {
		this.entries = [];
	}
	keys() {
		return this.entries.map(({ content }) => content);
	}
};
const DynamicFlag = {
	"NONE": 0,
	"0": "NONE",
	"REFERENCED": 1,
	"1": "REFERENCED",
	"NON_TEMPLATE": 2,
	"2": "NON_TEMPLATE",
	"INSERT": 4,
	"4": "INSERT"
};
function isBlockOperation(op) {
	const type = op.type;
	return type === 11 || type === 12 || type === 14 || type === 16 || type === 15;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/utils.ts
const newDynamic = () => ({
	flags: 1,
	children: []
});
const newBlock = (node) => ({
	type: 1,
	node,
	dynamic: newDynamic(),
	effect: [],
	operation: [],
	returns: [],
	tempId: 0
});
function wrapTemplate(node, dirs) {
	if (node.tagType === 3) {
		const otherStructuralDirs = [
			"if",
			"else-if",
			"else",
			"for"
		];
		if (!node.props.some((prop) => prop.type === 7 && otherStructuralDirs.includes(prop.name) && !dirs.includes(prop.name))) return node;
		const reserved = [];
		const pass = [];
		node.props.forEach((prop) => {
			if (prop.type === 7 && dirs.includes(prop.name)) reserved.push(prop);
			else pass.push(prop);
		});
		return extend({}, node, {
			type: 1,
			tag: "template",
			props: reserved,
			tagType: 3,
			children: [extend({}, node, { props: pass })]
		});
	}
	const reserved = [];
	const pass = [];
	node.props.forEach((prop) => {
		if (prop.type === 7 && (dirs.includes(prop.name) || prop.name === "bind" && prop.arg && prop.arg.type === 4 && prop.arg.content === "key" && dirs.includes("key"))) reserved.push(prop);
		else pass.push(prop);
	});
	return extend({}, node, {
		type: 1,
		tag: "template",
		props: reserved,
		tagType: 3,
		children: [extend({}, node, { props: pass })]
	});
}
const EMPTY_EXPRESSION = createSimpleExpression("", true);
//#endregion
//#region packages/compiler-vapor/src/utils.ts
const findProp = findProp$1;
/** find directive */
const findDir = findDir$1;
function propToExpression(prop) {
	return prop.type === 6 ? prop.value ? createSimpleExpression(prop.value.content, true, prop.value.loc) : EMPTY_EXPRESSION : prop.exp;
}
function isConstantExpression(exp) {
	return isLiteralWhitelisted(exp.content) || isGloballyAllowed(exp.content) || getLiteralExpressionValue(exp) !== null;
}
function isConstantBinding$1(exp, bindings) {
	return isConstantExpression(exp) || isStaticExpression(exp, bindings);
}
function isStaticExpression(node, bindings) {
	if (node.ast) return isConstantNode(node.ast, bindings);
	else if (node.ast === null) {
		if (!node.isStatic && (node.content === "true" || node.content === "false" || node.content === "null")) return true;
		return bindings[node.content] === "literal-const";
	}
	return false;
}
function resolveExpression(exp, isComponent) {
	if (!exp.isStatic) {
		const value = getLiteralExpressionValue(exp, isComponent);
		if (value !== null) return createSimpleExpression(value, true, exp.loc);
	}
	return exp;
}
function getLiteralExpressionValue(exp, excludeNumber) {
	if (exp.ast) {
		if (exp.ast.type === "StringLiteral") return exp.ast.value;
		else if (!excludeNumber && (exp.ast.type === "NumericLiteral" || exp.ast.type === "BigIntLiteral")) return String(exp.ast.value);
		else if (exp.ast.type === "TemplateLiteral") {
			let result = "";
			for (const [index, quasi] of exp.ast.quasis.entries()) {
				result += quasi.value.cooked;
				if (exp.ast.expressions[index]) {
					let expressionValue = getLiteralExpressionValue({ ast: exp.ast.expressions[index] });
					if (expressionValue == null) return null;
					else result += expressionValue;
				}
			}
			return result;
		}
	}
	return exp.isStatic ? exp.content : null;
}
function isInTransition(context) {
	const parentNode = context.parent && context.parent.node;
	return !!(parentNode && isTransitionNode(parentNode));
}
function isTransitionNode(node) {
	return node.type === 1 && isTransitionTag(node.tag);
}
/** Transition or TransitionGroup: hosts whose children render specially. */
function isTransitionHostNode(node) {
	return node.type === 1 && (isTransitionTag(node.tag) || isTransitionGroupTag(node.tag));
}
function isTransitionTag(tag) {
	tag = tag.toLowerCase();
	return tag === "transition" || tag === "vaportransition";
}
function isTransitionGroupTag(tag) {
	tag = tag.toLowerCase().replace(/-/g, "");
	return tag === "transitiongroup" || tag === "vaportransitiongroup";
}
function isKeepAliveTag(tag) {
	tag = tag.toLowerCase().replace(/-/g, "");
	return tag === "keepalive" || tag === "vaporkeepalive";
}
function isTeleportTag(tag) {
	tag = tag.toLowerCase();
	return tag === "teleport" || tag === "vaporteleport";
}
function isComponentTag(tag) {
	return tag === "component" || tag === "Component";
}
function isBuiltInComponent(tag) {
	if (isTeleportTag(tag)) return "VaporTeleport";
	else if (tag === "Suspense" || tag === "suspense") return "Suspense";
	else if (isKeepAliveTag(tag)) return "VaporKeepAlive";
	else if (isTransitionTag(tag)) return "VaporTransition";
	else if (isTransitionGroupTag(tag)) return "VaporTransitionGroup";
}
function getBlockShape(block) {
	if (block.returns.length !== 1) return 2;
	const root = block.dynamic.children.find((c) => c.id === block.returns[0]);
	if (root && root.operation && root.operation.type === 14) return 2;
	return block.node.type === 1 && block.node.children.every((child) => child.type === 2 || child.type === 5) ? 2 : 1;
}
//#endregion
//#region packages/compiler-vapor/src/transform.ts
init_objectSpread2();
const generatedVarRE = /^[nxr](\d+)$/;
const childContextInfoCache = /* @__PURE__ */ new WeakMap();
var TransformContext = class TransformContext {
	constructor(ir, node, options = {}) {
		this.ir = ir;
		this.node = node;
		this.selfName = null;
		this.parent = null;
		this.effectiveParent = null;
		this.index = 0;
		this.block = this.ir.block;
		this.template = "";
		this.templateRoot = false;
		this.templateIndexMap = /* @__PURE__ */ new Map();
		this.childrenTemplate = [];
		this.dynamic = this.ir.block.dynamic;
		this.imports = [];
		this.inVOnce = false;
		this.inVFor = 0;
		this.comment = [];
		this.component = this.ir.component;
		this.directive = this.ir.directive;
		this.slots = [];
		this.effectIndex = this.block.effect.length;
		this.operationIndex = this.block.operation.length;
		this.isLastEffectiveChild = true;
		this.isOnRightmostPath = true;
		this.isSingleRoot = false;
		this.templateCloseTags = void 0;
		this.templateCloseBlocks = false;
		this.globalId = 0;
		this.nextIdMap = null;
		this.ifIndex = 0;
		this.increaseId = () => {
			const id = getNextId(this.nextIdMap, this.globalId);
			this.globalId = getNextId(this.nextIdMap, id + 1);
			return id;
		};
		this.options = extend({}, defaultOptions, options);
		this.root = this;
		if (options.filename) this.selfName = getSelfName(options.filename);
		this.initNextIdMap();
	}
	enterBlock(ir, isVFor = false) {
		const { block, template, templateRoot, templateIndexMap, dynamic, childrenTemplate, slots, effectIndex, operationIndex } = this;
		this.block = ir;
		this.dynamic = ir.dynamic;
		this.template = "";
		this.templateRoot = false;
		this.templateIndexMap = templateIndexMap;
		this.childrenTemplate = [];
		this.slots = [];
		this.effectIndex = ir.effect.length;
		this.operationIndex = ir.operation.length;
		isVFor && this.inVFor++;
		return () => {
			this.registerTemplate();
			this.block = block;
			this.template = template;
			this.templateRoot = templateRoot;
			this.templateIndexMap = templateIndexMap;
			this.dynamic = dynamic;
			this.childrenTemplate = childrenTemplate;
			this.slots = slots;
			this.effectIndex = effectIndex;
			this.operationIndex = operationIndex;
			isVFor && this.inVFor--;
		};
	}
	initNextIdMap() {
		const binding = this.root.options.bindingMetadata;
		if (!binding) return;
		const keys = Object.keys(binding);
		if (keys.length === 0) return;
		const numbers = /* @__PURE__ */ new Set();
		for (const name of keys) {
			const m = generatedVarRE.exec(name);
			if (m) numbers.add(Number(m[1]));
		}
		if (numbers.size === 0) return;
		this.globalId = getNextId(this.nextIdMap = buildNextIdMap(numbers), 0);
	}
	reference() {
		if (this.dynamic.id !== void 0) return this.dynamic.id;
		this.dynamic.flags |= 1;
		return this.dynamic.id = this.increaseId();
	}
	nextIfIndex() {
		return this.ifIndex++;
	}
	getTemplateNamespace() {
		return this.node.type === 1 ? this.node.ns : 0;
	}
	canUseStaticTemplate() {
		if (!this.template) return false;
		if (this.inVFor) return false;
		if (this.dynamic.hasDynamicChild) return false;
		if (this.block.effect.length !== this.effectIndex) return false;
		if (this.block.operation.length !== this.operationIndex) return false;
		if (this.node.type === 2 || this.node.type === 3) return true;
		return this.node.type === 1 && this.node.tagType === 0 && !(this.options.isCustomElement(this.node.tag) || this.node.tag === "template");
	}
	pushTemplate(content, { root = false, static: isStatic = false } = {}) {
		const templateKey = JSON.stringify([
			this.getTemplateNamespace(),
			root,
			isStatic,
			content
		]);
		const existingIndex = this.templateIndexMap.get(templateKey);
		if (existingIndex !== void 0) return existingIndex;
		const ns = this.getTemplateNamespace();
		const newIndex = this.ir.template.entries.length;
		this.ir.template.entries.push({
			content,
			ns,
			root,
			static: isStatic
		});
		this.templateIndexMap.set(templateKey, newIndex);
		return newIndex;
	}
	registerTemplate() {
		if (!this.template) return -1;
		const id = this.pushTemplate(this.template, {
			root: this.templateRoot,
			static: this.canUseStaticTemplate()
		});
		return this.dynamic.template = id;
	}
	registerEffect(expressions, operation, getIndex, preserveOrder = false) {
		const operations = [operation].flat();
		expressions = expressions.filter((exp) => !isConstantExpression(exp));
		const once = expressions.every((e) => isConstantBinding$1(e, this.root.options.bindingMetadata));
		const needsEffect = operations.some((op) => op.type === 4 && op.listeners);
		if (this.inVOnce || once && !preserveOrder && !needsEffect) {
			this.registerOperation(...operations);
			return false;
		}
		const index = getIndex ? getIndex() : this.block.effect.length;
		this.block.effect.splice(index, 0, _objectSpread2({
			expressions,
			operations
		}, once && !needsEffect ? { once: true } : {}));
		if (getIndex) this.shiftEffectBoundaries(index);
		return true;
	}
	registerOperation(...node) {
		this.block.operation.push(...node);
	}
	effectBoundary() {
		return {
			operationIndex: this.operationIndex,
			effectIndex: this.effectIndex
		};
	}
	create(node, index) {
		let effectiveParent = this;
		while (effectiveParent && effectiveParent.node.type === 1 && effectiveParent.node.tagType === 3) effectiveParent = effectiveParent.parent;
		const childInfo = this.getChildContextInfo();
		const isLastEffectiveChild = childInfo.isLastEffectiveChild[index];
		const isOnRightmostPath = this.isOnRightmostPath && isLastEffectiveChild;
		const isSingleRoot = this.isSingleRootChild(childInfo);
		return Object.assign(Object.create(TransformContext.prototype), this, {
			node,
			parent: this,
			index,
			inVOnce: this.inVOnce && !isComponentNode(this.node),
			template: "",
			templateRoot: false,
			childrenTemplate: [],
			templateIndexMap: this.templateIndexMap,
			dynamic: newDynamic(),
			effectIndex: this.block.effect.length,
			operationIndex: this.block.operation.length,
			effectiveParent,
			isLastEffectiveChild,
			isOnRightmostPath,
			isSingleRoot,
			templateCloseTags: this.templateCloseTags,
			templateCloseBlocks: this.templateCloseBlocks
		});
	}
	shiftEffectBoundaries(index, dynamic = this.dynamic) {
		const operation = dynamic.operation;
		if (operation && isBlockOperation(operation) && operation.effectIndex !== void 0 && operation.effectIndex >= index) operation.effectIndex++;
		for (const child of dynamic.children) this.shiftEffectBoundaries(index, child);
	}
	getChildContextInfo() {
		const node = this.node;
		if (node.type !== 0 && node.type !== 1) return {
			node,
			hasSingleRootChild: true,
			isLastEffectiveChild: []
		};
		const cached = childContextInfoCache.get(this);
		if (cached && cached.node === node) return cached;
		const { children } = node;
		const isLastEffectiveChild = new Array(children.length);
		let hasFollowingEffectiveChild = false;
		for (let i = children.length - 1; i >= 0; i--) {
			isLastEffectiveChild[i] = !hasFollowingEffectiveChild;
			if (!isComponentChild(children[i])) hasFollowingEffectiveChild = true;
		}
		const childInfo = {
			node,
			hasSingleRootChild: hasSingleRootChild(children),
			isLastEffectiveChild
		};
		childContextInfoCache.set(this, childInfo);
		return childInfo;
	}
	isSingleRootChild(childInfo) {
		if (this.inVFor || !childInfo.hasSingleRootChild) return false;
		if (this.node.type === 0) return true;
		return this.node.type === 1 && (this.node.tagType === 3 || isTransitionNode(this.node) || isKeepAliveTag(this.node.tag)) && !!this.parent && this.isSingleRoot;
	}
};
function hasSingleRootChild(children) {
	let nonCommentChildren = 0;
	let hasEncounteredIf = false;
	let isSingleIfBlock = true;
	for (const child of children) {
		if (isCommentOrWhitespace(child)) continue;
		nonCommentChildren++;
		if (isIfChild(child)) {
			if (hasEncounteredIf) isSingleIfBlock = false;
			hasEncounteredIf = true;
		} else if (!hasEncounteredIf || !isElseChild(child)) isSingleIfBlock = false;
	}
	return nonCommentChildren === 1 || isSingleIfBlock;
}
function isComponentChild(child) {
	return child.type === 1 && child.tagType === 1;
}
function isIfChild(child) {
	return child.type === 9 || child.type === 1 && !!findDir$1(child, "if");
}
function isElseChild(child) {
	return child.type === 1 && !!findDir$1(child, /^else(-if)?$/, true);
}
const defaultOptions = {
	filename: "",
	prefixIdentifiers: true,
	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
};
function transform(node, options = {}) {
	const ir = {
		type: 0,
		node,
		source: node.source,
		template: new TemplateRegistry(),
		component: /* @__PURE__ */ new Set(),
		directive: /* @__PURE__ */ new Set(),
		block: newBlock(node),
		hasTemplateRef: false
	};
	const context = new TransformContext(ir, node, options);
	transformNode(context);
	ir.node.imports = context.imports;
	return ir;
}
function transformNode(context) {
	let { node } = context;
	const { nodeTransforms } = context.options;
	const exitFns = [];
	for (const nodeTransform of nodeTransforms) {
		const onExit = nodeTransform(node, context);
		if (onExit) {
			if (isArray$3(onExit)) exitFns.push(...onExit);
			else exitFns.push(onExit);
		}
		if (!context.node) return;
		else node = context.node;
	}
	context.node = node;
	let i = exitFns.length;
	while (i--) exitFns[i]();
	if (context.node.type === 0) context.registerTemplate();
}
function createStructuralDirectiveTransform(name, fn) {
	const matches = (n) => isString$1(name) ? n === name : name.includes(n);
	return (node, context) => {
		if (node.type === 1) {
			const { props } = node;
			if (node.tagType === 3 && props.some(isVSlot)) return;
			const exitFns = [];
			for (const prop of props) if (prop.type === 7 && matches(prop.name)) {
				const onExit = fn(node, prop, context);
				if (onExit) exitFns.push(onExit);
			}
			return exitFns;
		}
	};
}
/**
* Build a "next-id" map from an occupied number set.
* For each consecutive range [start..end], map every v in the range to end + 1.
* Example: input [0, 1, 2, 4] => { 0: 3, 1: 3, 2: 3, 4: 5 }.
*/
function buildNextIdMap(nums) {
	const map = /* @__PURE__ */ new Map();
	const arr = Array.from(new Set(nums)).sort((a, b) => a - b);
	if (arr.length === 0) return map;
	for (let i = 0; i < arr.length; i++) {
		let start = arr[i];
		let end = start;
		while (i + 1 < arr.length && arr[i + 1] === end + 1) {
			i++;
			end = arr[i];
		}
		for (let v = start; v <= end; v++) map.set(v, end + 1);
	}
	return map;
}
/**
* Return the available id for n using a map built by buildNextIdMap:
* - If n is not occupied, return n.
* - If n is occupied, return the mapped value
*/
function getNextId(map, n) {
	if (map && map.has(n)) return map.get(n);
	return n;
}
function isComponentNode(node) {
	return node.type === 1 && node.tagType === 1;
}
//#endregion
//#region packages/compiler-vapor/src/generators/utils.ts
/**
* Run a helper call inside the once ambient: a helper that creates its own
* effects at a v-once site has them run once like compiled ones do.
*/
function genOnce(call, context) {
	return genCall(context.helper("withOnce"), ["() => ", ...call]);
}
const IMPORT_EXP_START = "__IMPORT_EXP_START__";
const IMPORT_EXP_END = "__IMPORT_EXP_END__";
const IMPORT_EXPR_RE = new RegExp(`${IMPORT_EXP_START}(.*?)${IMPORT_EXP_END}`, "g");
const NEWLINE = Symbol(`newline`);
/** increase offset but don't push actual code */
const LF = Symbol(`line feed`);
const INDENT_START = Symbol(`indent start`);
const INDENT_END = Symbol(`indent end`);
function buildCodeFragment(...frag) {
	return [
		frag,
		frag.push.bind(frag),
		frag.unshift.bind(frag)
	];
}
function genMulti([left, right, seg, placeholder], ...frags) {
	if (placeholder) {
		while (frags.length > 0 && !frags[frags.length - 1]) frags.pop();
		frags = frags.map((frag) => frag || placeholder);
	} else frags = frags.filter(Boolean);
	const frag = [];
	push(left);
	for (let [i, fn] of frags.entries()) {
		push(fn);
		if (i < frags.length - 1) push(seg);
	}
	push(right);
	return frag;
	function push(fn) {
		if (!isArray$3(fn)) fn = [fn];
		frag.push(...fn);
	}
}
const DELIMITERS_ARRAY = [
	"[",
	"]",
	", "
];
const DELIMITERS_ARRAY_NEWLINE = [
	[
		"[",
		INDENT_START,
		NEWLINE
	],
	[
		INDENT_END,
		NEWLINE,
		"]"
	],
	[",", NEWLINE]
];
const DELIMITERS_OBJECT = [
	"{ ",
	" }",
	", "
];
const DELIMITERS_OBJECT_NEWLINE = [
	[
		"{",
		INDENT_START,
		NEWLINE
	],
	[
		INDENT_END,
		NEWLINE,
		"}"
	],
	[",", NEWLINE]
];
function genCall(name, ...frags) {
	const hasPlaceholder = isArray$3(name);
	return [hasPlaceholder ? name[0] : name, ...genMulti([
		"(",
		")",
		", ",
		hasPlaceholder ? name[1] : "null"
	], ...frags)];
}
function getParserOptions(plugins) {
	return { plugins: plugins ? plugins.some((plugin) => plugin === "typescript") ? plugins : [...plugins, "typescript"] : ["typescript"] };
}
function codeFragmentToString(code, context) {
	const { options: { filename, sourceMap } } = context;
	let map;
	if (sourceMap) {
		map = new import_source_map.SourceMapGenerator();
		map.setSourceContent(filename, context.ir.source);
		map._sources.add(filename);
	}
	let codegen = "";
	const pos = {
		line: 1,
		column: 1,
		offset: 0
	};
	let indentLevel = 0;
	for (let frag of code) {
		if (!frag) continue;
		if (frag === NEWLINE) frag = [`\n${`  `.repeat(indentLevel)}`, 0];
		else if (frag === INDENT_START) {
			indentLevel++;
			continue;
		} else if (frag === INDENT_END) {
			indentLevel--;
			continue;
		} else if (frag === LF) {
			pos.line++;
			pos.column = 0;
			pos.offset++;
			continue;
		}
		if (isString$1(frag)) frag = [frag];
		let [code, newlineIndex = -2, loc, name] = frag;
		codegen += code;
		if (map) {
			if (loc) addMapping(loc.start, name);
			if (newlineIndex === -3) advancePositionWithMutation(pos, code);
			else {
				pos.offset += code.length;
				if (newlineIndex === -2) pos.column += code.length;
				else {
					if (newlineIndex === -1) newlineIndex = code.length - 1;
					pos.line++;
					pos.column = code.length - newlineIndex;
				}
			}
			if (loc && loc !== locStub) addMapping(loc.end);
		}
	}
	return [codegen, map];
	function addMapping(loc, name = null) {
		const { _names, _mappings } = map;
		if (name !== null && !_names.has(name)) _names.add(name);
		_mappings.add({
			originalLine: loc.line,
			originalColumn: loc.column - 1,
			generatedLine: pos.line,
			generatedColumn: pos.column - 1,
			source: filename,
			name
		});
	}
}
/** Formats a numeric flags argument with its dev-only name annotation. */
function genFlags(flags, names) {
	return `${flags} /* ${names.join(", ")} */`;
}
//#endregion
//#region packages/compiler-vapor/src/generators/dom.ts
function genInsertNode({ parent, elements, anchor }, { helper }) {
	let element = elements.map((el) => `n${el}`).join(", ");
	if (elements.length > 1) element = `[${element}]`;
	return [NEWLINE, ...genCall(helper("insert"), element, `n${parent}`, anchor === void 0 ? void 0 : `n${anchor}`)];
}
//#endregion
//#region packages/compiler-vapor/src/generators/expression.ts
init_objectSpread2();
function genExpression(node, context, assignment, asParams = false) {
	node = context.getExpressionReplacement(node);
	const { content, ast, isStatic, loc } = node;
	const { options } = context;
	const { inline } = options;
	if (isStatic) return [[
		JSON.stringify(content),
		-2,
		loc
	]];
	if (!node.content.trim() || ast === false || isConstantExpression(node)) return [[
		content,
		-2,
		loc
	], assignment && ` = ${assignment}`];
	if (ast === null) return genIdentifier(content, context, loc, assignment);
	const ids = [];
	const parentStackMap = /* @__PURE__ */ new Map();
	const parentStack = [];
	walkIdentifiers(ast, (id, _, __, isReference, isLocal) => {
		if (isLocal) {
			if (!id.typeAnnotation && !id.optional) return;
		} else if (!isReference) return;
		ids.push(id);
		parentStackMap.set(id, parentStack.slice());
	}, asParams, parentStack);
	let hasMemberExpression = false;
	if (ids.length) {
		const [frag, push] = buildCodeFragment();
		let lastEnd = 0;
		ids.sort((a, b) => a.start - b.start).forEach((id) => {
			const idStart = id.start - 1;
			const idEnd = id.end - 1;
			const source = content.slice(idStart, idEnd);
			const parentStack = parentStackMap.get(id);
			const parent = parentStack[parentStack.length - 1];
			let start = idStart;
			let end = idEnd;
			if (inline && options.bindingMetadata && options.bindingMetadata[source] === "setup-let" && parent && parent.type === "UpdateExpression" && parent.argument === id) {
				start = parent.start - 1;
				end = parent.end - 1;
			}
			if (start < lastEnd) return;
			const leadingText = content.slice(lastEnd, start);
			if (leadingText.length) push([leadingText, -3]);
			hasMemberExpression || (hasMemberExpression = parent && (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression"));
			push(...genIdentifier(asParams ? id.name : source, context, {
				start: advancePositionWithClone(node.loc.start, source, start),
				end: advancePositionWithClone(node.loc.start, source, end),
				source
			}, hasMemberExpression ? void 0 : assignment, id, parent, parentStack, node));
			lastEnd = end;
		});
		if (lastEnd < content.length) push([content.slice(lastEnd), -3]);
		if (assignment && hasMemberExpression) push(` = ${assignment}`);
		return frag;
	} else return [[
		content,
		-3,
		loc
	]];
}
function genIdentifier(raw, context, loc, assignment, id, parent, parentStack, sourceNode) {
	const { options, helper, identifiers } = context;
	const { inline, bindingMetadata } = options;
	let name = raw;
	const idMap = identifiers[raw];
	if (idMap && idMap.length) {
		const replacement = idMap[0];
		if (isString$1(replacement)) {
			if (parent && parent.type === "ObjectProperty" && parent.shorthand) return [[
				`${name}: ${replacement}`,
				-2,
				loc
			]];
			else return [[
				replacement,
				-2,
				loc
			]];
		} else return genExpression(replacement, context, assignment);
	}
	let prefix;
	const type = bindingMetadata && bindingMetadata[raw];
	const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack || []);
	const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
	const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
	if (isStaticProperty(parent) && parent.shorthand && !(inline && type === "setup-let" && isDestructureAssignment)) prefix = `${raw}: `;
	if (inline) switch (type) {
		case "setup-let":
			if (isAssignmentLVal) {
				const { right, operator } = parent;
				const source = sourceNode;
				const sourceContent = source.content;
				const rightStart = right.start - 1;
				const rightEnd = right.end - 1;
				const rightContent = sourceContent.slice(rightStart, rightEnd);
				const rightExp = createSimpleExpression(rightContent, false, {
					start: advancePositionWithClone(source.loc.start, sourceContent, rightStart),
					end: advancePositionWithClone(source.loc.start, sourceContent, rightEnd),
					source: rightContent
				});
				rightExp.ast = parseExp(context, rightContent);
				return [
					prefix,
					`${helper("isRef")}(${raw}) ? ${raw}.value ${operator} `,
					...genExpression(rightExp, context),
					` : `,
					[
						raw,
						-2,
						loc,
						name
					]
				];
			} else if (isUpdateArg) {
				const { prefix: isPrefix, operator } = parent;
				const updatePrefix = isPrefix ? operator : ``;
				const updatePostfix = isPrefix ? `` : operator;
				raw = `${helper("isRef")}(${raw}) ? ${updatePrefix}${raw}.value${updatePostfix} : ${updatePrefix}${raw}${updatePostfix}`;
			} else if (!isDestructureAssignment) name = raw = assignment ? `${helper("isRef")}(${raw}) ? (${raw}.value = ${assignment}) : (${raw} = ${assignment})` : unref();
			break;
		case "setup-ref":
			name = raw = withAssignment(`${raw}.value`);
			break;
		case "setup-maybe-ref":
			raw = isAssignmentLVal || isUpdateArg || isDestructureAssignment ? name = `${raw}.value` : assignment ? `${helper("isRef")}(${raw}) ? (${raw}.value = ${assignment}) : null` : unref();
			break;
		case "props":
			raw = genPropsAccessExp(raw);
			break;
		case "props-aliased":
			raw = genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
			break;
		default: raw = withAssignment(raw);
	}
	else {
		if (canPrefix(raw)) {
			if (type === "props-aliased") raw = `$props['${bindingMetadata.__propsAliases[raw]}']`;
			else raw = `${type === "props" ? "$props" : "_ctx"}.${raw}`;
		}
		raw = withAssignment(raw);
	}
	return [prefix, [
		raw,
		-2,
		loc,
		name
	]];
	function withAssignment(s) {
		return assignment ? `${s} = ${assignment}` : s;
	}
	function unref() {
		return `${helper("unref")}(${raw})`;
	}
}
function canPrefix(name) {
	if (isGloballyAllowed(name)) return false;
	if (name === "require" || name === "$props" || name === "$emit" || name === "$attrs" || name === "$slots") return false;
	return true;
}
function processExpressions(context, expressions, shouldDeclare) {
	const expressionReplacements = /* @__PURE__ */ new Map();
	const { seenVariable, variableToExpMap, expressionRecords, seenIdentifier, updatedVariable, eagerVariable } = analyzeExpressions(expressions);
	const reservedNames = new Set(seenIdentifier);
	const varDeclarations = processRepeatedVariables(context, seenVariable, variableToExpMap, expressionRecords, seenIdentifier, updatedVariable, eagerVariable, reservedNames, expressionReplacements);
	const expDeclarations = processRepeatedExpressions(context, expressions, varDeclarations, updatedVariable, expressionRecords, reservedNames, expressionReplacements);
	return _objectSpread2(_objectSpread2({}, genDeclarations([...varDeclarations, ...expDeclarations], context, shouldDeclare)), {}, { expressionReplacements });
}
function analyzeExpressions(expressions) {
	const seenVariable = Object.create(null);
	const variableToExpMap = /* @__PURE__ */ new Map();
	const expressionRecords = /* @__PURE__ */ new Map();
	const seenIdentifier = /* @__PURE__ */ new Set();
	const updatedVariable = /* @__PURE__ */ new Set();
	const eagerVariable = /* @__PURE__ */ new Set();
	const getRecord = (exp) => {
		let record = expressionRecords.get(exp);
		if (!record) expressionRecords.set(exp, record = { variables: [] });
		return record;
	};
	const registerVariable = (name, exp, isIdentifier, loc, parentStack = []) => {
		if (isIdentifier) seenIdentifier.add(name);
		seenVariable[name] = (seenVariable[name] || 0) + 1;
		variableToExpMap.set(name, (variableToExpMap.get(name) || /* @__PURE__ */ new Set()).add(exp));
		getRecord(exp).variables.push({
			name,
			loc
		});
		if (parentStack.some((p) => p.type === "UpdateExpression" || p.type === "AssignmentExpression")) updatedVariable.add(name);
		if (isIdentifier || !isLazilyEvaluated(parentStack)) eagerVariable.add(name);
	};
	for (const exp of expressions) {
		if (!exp.ast) {
			exp.ast === null && registerVariable(exp.content, exp, true);
			continue;
		}
		const seenParents = /* @__PURE__ */ new Set();
		walkIdentifiers(exp.ast, (currentNode, parent, parentStack) => {
			if (parent && isMemberExpression(parent) && !seenParents.has(parent)) {
				var _parentStack$index;
				seenParents.add(parent);
				let hasGlobalIdentifier = false;
				const memberExp = extractMemberExpression(parent, (id) => {
					registerVariable(id.name, exp, true, {
						start: id.start,
						end: id.end
					});
					if (isGloballyAllowed(id.name)) hasGlobalIdentifier = true;
				});
				if (memberExp === void 0) return;
				const parentOfMemberExp = parentStack[parentStack.length - 2];
				if (parentOfMemberExp && isCallExpression(parentOfMemberExp)) return;
				let chainChild = parent;
				let index = parentStack.length - 2;
				while (((_parentStack$index = parentStack[index]) === null || _parentStack$index === void 0 ? void 0 : _parentStack$index.type) === "TSNonNullExpression") chainChild = parentStack[index--];
				const chainParent = parentStack[index];
				if (chainParent && chainParent.type === "OptionalMemberExpression" && !chainParent.optional && chainParent.object === chainChild) return;
				if (hasGlobalIdentifier) return;
				registerVariable(memberExp, exp, false, {
					start: parent.start,
					end: parent.end
				}, parentStack);
			} else if (!parentStack.some(isMemberExpression)) registerVariable(currentNode.name, exp, true, {
				start: currentNode.start,
				end: currentNode.end
			}, parentStack);
		});
	}
	return {
		seenVariable,
		seenIdentifier,
		variableToExpMap,
		expressionRecords,
		updatedVariable,
		eagerVariable
	};
}
function getProcessedExpression(exp, expressionReplacements) {
	return expressionReplacements.get(exp) || exp;
}
function setExpressionReplacement(expressionReplacements, exp, content, ast) {
	expressionReplacements.set(exp, extend({ ast }, createSimpleExpression(content, exp.isStatic, exp.loc, exp.constType)));
}
/**
* Whether a node is only evaluated lazily, given its ancestor chain - i.e. it
* may be skipped entirely when a preceding condition is not met.
*/
const isLazilyEvaluated = (parentStack) => {
	for (let i = parentStack.length - 1; i > 0; i--) {
		const child = parentStack[i];
		const parent = parentStack[i - 1];
		switch (parent.type) {
			case "ConditionalExpression":
				if (parent.test !== child) return true;
				break;
			case "LogicalExpression":
				if (parent.right === child) return true;
				break;
			case "OptionalCallExpression":
				if (parent.arguments.includes(child)) return true;
				break;
			case "OptionalMemberExpression":
				if (parent.computed && parent.property === child) return true;
				break;
			default: if (isFunctionType(parent)) return true;
		}
	}
	return false;
};
function processRepeatedVariables(context, seenVariable, variableToExpMap, expressionRecords, seenIdentifier, updatedVariable, eagerVariable, reservedNames, expressionReplacements) {
	const declarations = [];
	const declaredNames = /* @__PURE__ */ new Set();
	const replacementPlan = /* @__PURE__ */ new Map();
	for (const [name, exps] of variableToExpMap) {
		if (updatedVariable.has(name)) continue;
		if (!eagerVariable.has(name)) continue;
		if (isGloballyAllowed(name)) continue;
		if (seenVariable[name] > 1 && exps.size > 0) {
			const isIdentifier = seenIdentifier.has(name);
			const varName = isIdentifier ? name : getUniqueDeclarationName(genVarName(name), reservedNames);
			exps.forEach((node) => {
				if (node.ast && varName !== name) {
					for (const variable of getExpressionVariables(expressionRecords, node)) if (variable.name === name && variable.loc) queueContentReplacement(replacementPlan, node, {
						start: variable.loc.start - 1,
						end: variable.loc.end - 1,
						content: varName
					});
				}
			});
			if (!declaredNames.has(varName) && (!isIdentifier || shouldDeclareVariable(name, expressionRecords, exps))) {
				declaredNames.add(varName);
				declarations.push({
					name: varName,
					isIdentifier,
					value: extend({ ast: isIdentifier ? null : parseExp(context, name) }, createSimpleExpression(name)),
					rawName: name,
					exps,
					seenCount: seenVariable[name]
				});
			}
		}
	}
	applyReplacementPlan(context, expressionReplacements, replacementPlan);
	return declarations;
}
function shouldDeclareVariable(name, expressionRecords, exps) {
	const variableUsages = [];
	let allSingleVariable = true;
	let hasRepeatedName = false;
	let hasDifferentLength = false;
	outer: for (const exp of exps) {
		const variables = getExpressionVariables(expressionRecords, exp);
		if (allSingleVariable && variables.length !== 1) allSingleVariable = false;
		if (!hasDifferentLength && variableUsages.length > 0 && variables.length !== variableUsages[0].length) hasDifferentLength = true;
		let nameCount = 0;
		for (const variable of variables) if (variable.name === name && ++nameCount > 1) {
			hasRepeatedName = true;
			break outer;
		}
		variableUsages.push(variables);
	}
	if (allSingleVariable) return true;
	if (hasRepeatedName) return true;
	const first = variableUsages[0];
	if (hasDifferentLength) {
		for (const variables of variableUsages) {
			if (variables.length === first.length) continue;
			const longer = variables.length > first.length ? variables : first;
			const shorter = variables.length > first.length ? first : variables;
			const shorterNames = /* @__PURE__ */ new Set();
			for (const variable of shorter) shorterNames.add(variable.name);
			let isSubset = true;
			for (const variable of longer) if (!shorterNames.has(variable.name)) {
				isSubset = false;
				break;
			}
			if (isSubset) return false;
		}
		return true;
	}
	for (const variables of variableUsages) for (let i = 0; i < variables.length; i++) if (variables[i].name !== first[i].name) return true;
	return false;
}
function processRepeatedExpressions(context, expressions, varDeclarations, updatedVariable, expressionRecords, reservedNames, expressionReplacements) {
	const declarations = [];
	const seenExp = /* @__PURE__ */ new Map();
	for (const exp of expressions) {
		var _expressionRecords$ge;
		const vars = (_expressionRecords$ge = expressionRecords.get(exp)) === null || _expressionRecords$ge === void 0 ? void 0 : _expressionRecords$ge.variables;
		if (!vars) continue;
		const processed = getProcessedExpression(exp, expressionReplacements);
		if (canCacheExpression(processed, vars, updatedVariable)) {
			const seen = seenExp.get(processed.content);
			if (seen) seen.count++;
			else seenExp.set(processed.content, {
				count: 1,
				first: exp
			});
		}
	}
	const repeatedExpressions = [...seenExp].sort(([contentA], [contentB]) => contentB.length - contentA.length);
	for (const [content, { count, first }] of repeatedExpressions) if (count > 1) {
		const removedDeclarations = [];
		for (let i = varDeclarations.length - 1; i >= 0; i--) {
			const item = varDeclarations[i];
			if (!item.exps || !item.seenCount) continue;
			if ([...item.exps].every((node) => getProcessedExpression(node, expressionReplacements).content === content && item.seenCount === count)) {
				removedDeclarations.push({
					name: item.name,
					rawName: item.rawName
				});
				reservedNames.delete(item.name);
				varDeclarations.splice(i, 1);
			}
		}
		const value = extend({}, getProcessedExpression(first, expressionReplacements));
		const restorePlan = [];
		for (const { name, rawName } of removedDeclarations) restorePlan.push(...findIdentifierReplacements(value, name, rawName));
		if (restorePlan.length) {
			value.content = applyContentReplacements(value.content, restorePlan);
			if (value.ast) value.ast = parseExp(context, value.content);
		}
		const varName = getUniqueDeclarationName(genVarName(content), reservedNames);
		declarations.push({
			name: varName,
			value
		});
		for (const exp of expressions) {
			const processed = getProcessedExpression(exp, expressionReplacements);
			if (processed.content === content) setExpressionReplacement(expressionReplacements, exp, varName, null);
			else if (!content.includes("?.") && processed.content.includes(content)) {
				const replacements = findContentReplacements(processed, content, varName);
				if (replacements.length) {
					const replacedContent = applyContentReplacements(processed.content, replacements);
					setExpressionReplacement(expressionReplacements, exp, replacedContent, parseExp(context, replacedContent));
				}
			}
		}
	}
	return declarations;
}
function canCacheExpression(processed, vars, updatedVariable) {
	if (!processed.ast || processed.ast.type === "Identifier") return false;
	for (const { name } of vars) if (updatedVariable.has(name) || isGloballyAllowed(name)) return false;
	return true;
}
function getExpressionVariables(expressionRecords, exp) {
	var _expressionRecords$ge2;
	return ((_expressionRecords$ge2 = expressionRecords.get(exp)) === null || _expressionRecords$ge2 === void 0 ? void 0 : _expressionRecords$ge2.variables) || [];
}
function queueContentReplacement(replacementPlan, exp, replacement) {
	const replacements = replacementPlan.get(exp);
	if (replacements) replacements.push(replacement);
	else replacementPlan.set(exp, [replacement]);
}
function applyReplacementPlan(context, expressionReplacements, replacementPlan) {
	for (const [exp, replacements] of replacementPlan) {
		if (!replacements.length) continue;
		const content = applyContentReplacements(getProcessedExpression(exp, expressionReplacements).content, replacements);
		setExpressionReplacement(expressionReplacements, exp, content, parseExp(context, content));
	}
}
function findContentReplacements(exp, content, replacement) {
	const nodeRanges = getNodeRanges(exp);
	if (!nodeRanges.size) return [];
	const replacements = [];
	let searchStart = 0;
	let start = exp.content.indexOf(content, searchStart);
	while (start !== -1) {
		const end = start + content.length;
		if (nodeRanges.has(`${start}:${end}`)) {
			replacements.push({
				start,
				end,
				content: replacement
			});
			searchStart = end;
		} else searchStart = start + 1;
		start = exp.content.indexOf(content, searchStart);
	}
	return replacements;
}
function findIdentifierReplacements(exp, name, replacement) {
	const replacements = [];
	for (const { start, end } of getIdentifierRanges(exp)) if (exp.content.slice(start, end) === name) replacements.push({
		start,
		end,
		content: replacement
	});
	return replacements;
}
function getNodeRanges(exp) {
	const ranges = /* @__PURE__ */ new Set();
	if (!exp.ast || typeof exp.ast !== "object") return ranges;
	walk$2(exp.ast, { enter(node) {
		if (isFunctionType(node) || node.type === "TemplateElement" || node.type.startsWith("TS") && !TS_NODE_TYPES.includes(node.type)) return this.skip();
		if (node.start != null && node.end != null) ranges.add(`${node.start - 1}:${node.end - 1}`);
	} });
	return ranges;
}
function getIdentifierRanges(exp) {
	if (!exp.ast || typeof exp.ast !== "object") return [];
	const identifiers = [];
	walkIdentifiers(exp.ast, (id) => {
		identifiers.push({
			start: id.start - 1,
			end: id.end - 1
		});
	}, false);
	return identifiers;
}
function applyContentReplacements(content, replacements) {
	replacements.sort((a, b) => b.start - a.start).forEach(({ start, end, content: replacement }) => {
		content = content.slice(0, start) + replacement + content.slice(end);
	});
	return content;
}
function genDeclarations(declarations, context, shouldDeclare) {
	const [frag, push] = buildCodeFragment();
	const ids = Object.create(null);
	const varNames = /* @__PURE__ */ new Set();
	declarations.forEach(({ name, isIdentifier, value }) => {
		if (isIdentifier) {
			const varName = ids[name] = context.getUniqueLocalName(`_${name}`, varNames);
			if (shouldDeclare) push(`const `);
			push(`${varName} = `, ...genExpression(value, context), NEWLINE);
		}
	});
	declarations.forEach(({ name, isIdentifier, value }) => {
		if (!isIdentifier) {
			const varName = context.getUniqueLocalName(`_${name}`, varNames);
			if (shouldDeclare) push(`const `);
			push(`${varName} = `, ...context.withId(() => genExpression(value, context), ids), NEWLINE);
			ids[name] = varName;
		}
	});
	return {
		ids,
		frag,
		varNames: [...varNames]
	};
}
function parseExp(context, content) {
	return (0, import_lib.parseExpression)(`(${content})`, getParserOptions(context.options.expressionPlugins));
}
function genVarName(exp) {
	return `${exp.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/_+$/, "")}`;
}
function getUniqueDeclarationName(baseName, reservedNames) {
	const normalizedBase = baseName || "exp";
	let name = normalizedBase;
	let i = 1;
	while (reservedNames.has(name)) name = `${normalizedBase}_${i++}`;
	reservedNames.add(name);
	return name;
}
/**
* Returns the source of a member expression, or `undefined` if it contains a
* node that cannot be extracted, e.g. `foo[bar ? 'a' : 'b']`. Such expressions
* must not be cached - the extracted source would be incomplete.
*/
function extractMemberExpression(exp, onIdentifier) {
	if (!exp) return;
	switch (exp.type) {
		case "Identifier":
			onIdentifier(exp);
			return exp.name;
		case "StringLiteral": return exp.extra ? exp.extra.raw : exp.value;
		case "NumericLiteral": return exp.value.toString();
		case "BinaryExpression": {
			var _exp$extra;
			const left = extractMemberExpression(exp.left, onIdentifier);
			const right = extractMemberExpression(exp.right, onIdentifier);
			if (left === void 0 || right === void 0) return;
			const expression = `${left} ${exp.operator} ${right}`;
			return ((_exp$extra = exp.extra) === null || _exp$extra === void 0 ? void 0 : _exp$extra.parenthesized) ? `(${expression})` : expression;
		}
		case "CallExpression":
		case "OptionalCallExpression": {
			const callee = extractMemberExpression(exp.callee, onIdentifier);
			const args = exp.arguments.map((arg) => extractMemberExpression(arg, onIdentifier));
			if (callee === void 0 || args.some((arg) => arg === void 0)) return;
			return `${callee}${exp.type === "OptionalCallExpression" ? "?." : ""}(${args.join(", ")})`;
		}
		case "MemberExpression":
		case "OptionalMemberExpression": {
			const object = extractMemberExpression(exp.object, onIdentifier);
			const property = extractMemberExpression(exp.property, exp.computed ? onIdentifier : NOOP);
			if (object === void 0 || property === void 0) return;
			const optional = exp.type === "OptionalMemberExpression" && exp.optional;
			return `${object}${exp.computed ? `${optional ? "?." : ""}[${property}]` : `${optional ? "?." : "."}${property}`}`;
		}
		case "TSNonNullExpression": return extractMemberExpression(exp.expression, onIdentifier);
		default: return;
	}
}
const isCallExpression = (node) => {
	return node.type === "CallExpression" || node.type === "OptionalCallExpression";
};
const isMemberExpression = (node) => {
	return node.type === "MemberExpression" || node.type === "OptionalMemberExpression" || node.type === "TSNonNullExpression";
};
//#endregion
//#region packages/compiler-vapor/src/generators/event.ts
function genSetEvent(oper, context) {
	const { helper } = context;
	const { element, key, keyOverride, value, modifiers, delegate, effect } = oper;
	let handler;
	if (delegate) {
		context.delegates.add(key.content);
		if (!context.block.operation.some(isSameDelegateEvent)) return [
			NEWLINE,
			`n${element}.$evt${key.content} = `,
			...genDirectHandler()
		];
	}
	const name = genName();
	const eventOptions = genEventOptions();
	return [NEWLINE, ...genCall(helper(effect ? "onBinding" : delegate ? "delegate" : "on"), `n${element}`, name, genHandler(), eventOptions)];
	function genHandler() {
		return handler || (handler = genEventHandler(context, [value], modifiers));
	}
	function genInvoker() {
		return [
			`${helper("createInvoker")}(`,
			...genHandler(),
			`)`
		];
	}
	function genDirectHandler() {
		return modifiers.keys.length || modifiers.nonKeys.length ? genEventHandler(context, [value], modifiers, { modifierHelper: "vapor" }) : genInvoker();
	}
	function genName() {
		const expr = genExpression(key, context);
		if (keyOverride) {
			const find = JSON.stringify(keyOverride[0]);
			const replacement = JSON.stringify(keyOverride[1]);
			const wrapped = [
				"(",
				...expr,
				")"
			];
			return [
				...wrapped,
				` === ${find} ? ${replacement} : `,
				...wrapped
			];
		} else return genExpression(key, context);
	}
	function genEventOptions() {
		let { options } = modifiers;
		if (!options.length) return;
		return genMulti(DELIMITERS_OBJECT_NEWLINE, ...options.map((option) => [`${option}: true`]));
	}
	function isSameDelegateEvent(op) {
		if (op.type === 6 && op !== oper && op.delegate && op.element === oper.element && op.key.content === key.content) return true;
	}
}
function genSetDynamicEvents(oper, context) {
	const { helper } = context;
	return [NEWLINE, ...genCall(helper("setDynamicEvents"), `n${oper.element}`, genExpression(oper.event, context))];
}
function genEventHandler(context, values, modifiers = {
	nonKeys: [],
	keys: []
}, options = {}) {
	const { asComponentProp = false, extraWrap = false, modifierHelper = "runtime" } = options;
	const useVaporModifierHelper = modifierHelper === "vapor";
	let handlerExp = [];
	if (values) {
		values.forEach((value, index) => {
			let exp = [];
			if (value && value.content.trim()) {
				if (isMemberExpression$1(value, context.options)) {
					exp = genExpression(value, context);
					if (!isConstantBinding(value, context) && !asComponentProp) {
						const isTSNode = value.ast && TS_NODE_TYPES.includes(value.ast.type);
						exp = [
							`e => `,
							isTSNode ? "(" : "",
							...exp,
							isTSNode ? ")" : "",
							`(e)`
						];
					}
				} else if (isFnExpression(value, context.options)) exp = genExpression(value, context);
				else {
					const referencesEvent = value.content.includes("$event");
					const hasMultipleStatements = value.content.includes(`;`);
					const expr = referencesEvent ? context.withId(() => genExpression(value, context), { $event: null }) : genExpression(value, context);
					exp = [
						referencesEvent ? "$event => " : "() => ",
						hasMultipleStatements ? "{" : "(",
						...expr,
						hasMultipleStatements ? "}" : ")"
					];
				}
				handlerExp = handlerExp.concat([index !== 0 ? ", " : "", ...exp]);
			}
		});
		if (values.length > 1) handlerExp = [
			"[",
			...handlerExp,
			"]"
		];
	}
	if (handlerExp.length === 0) handlerExp = ["() => {}"];
	const { keys, nonKeys } = modifiers;
	if (nonKeys.length) handlerExp = genWithModifiers(context, handlerExp, nonKeys, useVaporModifierHelper && !keys.length);
	if (keys.length) handlerExp = genWithKeys(context, handlerExp, keys, useVaporModifierHelper);
	if (extraWrap) handlerExp.unshift(`() => `);
	return handlerExp;
}
function genWithModifiers(context, handler, nonKeys, useVaporHelper = false) {
	return genCall(context.helper(useVaporHelper ? "withVaporModifiers" : "withModifiers"), handler, JSON.stringify(nonKeys));
}
function genWithKeys(context, handler, keys, useVaporHelper = false) {
	return genCall(context.helper(useVaporHelper ? "withVaporKeys" : "withKeys"), handler, JSON.stringify(keys));
}
function isConstantBinding(value, context) {
	if (value.ast === null) {
		if (context.options.bindingMetadata[value.content] === "setup-const") return true;
	}
}
//#endregion
//#region packages/compiler-vapor/src/generators/for.ts
function genFor(oper, context) {
	const { helper } = context;
	const { source, value, key, index, render, keyProp, once, id, component, onlyChild, slotRoot, wrappedRows } = oper;
	const sourceExpr = [
		"() => (",
		...genExpression(source, context),
		")"
	];
	const plugins = context.options.expressionPlugins;
	const idToPathMap = parseValueDestructure(value, context);
	const keyToPathMap = parseValueDestructure(key, context);
	const indexToPathMap = parseValueDestructure(index, context);
	const [depth, exitScope] = context.enterScope();
	const itemVar = `_for_item${depth}`;
	const idMap = buildDestructureIdMap(idToPathMap, `${itemVar}.value`, plugins);
	idMap[itemVar] = null;
	const args = [itemVar];
	if (key) {
		const keyVar = `_for_key${depth}`;
		args.push(`, ${keyVar}`);
		Object.assign(idMap, buildDestructureIdMap(keyToPathMap, `${keyVar}.value`, plugins));
		idMap[keyVar] = null;
	} else if (index) args.push(", _");
	if (index) {
		const indexVar = `_for_index${depth}`;
		args.push(`, ${indexVar}`);
		Object.assign(idMap, buildDestructureIdMap(indexToPathMap, `${indexVar}.value`, plugins));
		idMap[indexVar] = null;
	}
	const { selectorPatterns, keyOnlyBindingPatterns, skippedEffectIndexes } = matchPatterns(render, keyProp, idMap, context);
	const selectorDeclarations = [];
	const selectorName = (i) => selectorPatterns.length > 1 ? `_selector${id}_${i}` : `_selector${id}`;
	for (let i = 0; i < selectorPatterns.length; i++) {
		const { selector } = selectorPatterns[i];
		selectorDeclarations.push(`const ${selectorName(i)} = `, ...genCall(helper("createSelector"), [`() => `, ...genExpression(selector, context)]), NEWLINE);
	}
	const blockFn = context.withId(() => {
		const frag = [];
		frag.push("(", ...args, ") => {", INDENT_START);
		if (selectorPatterns.length || keyOnlyBindingPatterns.length) frag.push(...genBlockContent(render, context, false, () => {
			const patternFrag = [];
			for (let i = 0; i < selectorPatterns.length; i++) {
				const { effect } = selectorPatterns[i];
				patternFrag.push(NEWLINE, `${selectorName(i)}(`, ...genExpression(keyProp, context), `, () => {`, INDENT_START);
				for (const oper of effect.operations) patternFrag.push(...genOperation(oper, context));
				patternFrag.push(INDENT_END, NEWLINE, `})`);
			}
			for (const { effect } of keyOnlyBindingPatterns) for (const oper of effect.operations) patternFrag.push(...genOperation(oper, context));
			return patternFrag;
		}, skippedEffectIndexes));
		else frag.push(...genBlockContent(render, context));
		frag.push(INDENT_END, NEWLINE, "}");
		return frag;
	}, idMap);
	exitScope();
	const flags = genForFlags(onlyChild, component, isFragmentBlock(render), !component && isSingleNodeBlock(render), once, slotRoot, wrappedRows);
	const onResetCalls = [];
	for (let i = 0; i < selectorPatterns.length; i++) onResetCalls.push(NEWLINE, `n${id}.onReset(${selectorName(i)}.reset)`);
	return [
		NEWLINE,
		...selectorDeclarations,
		`const n${id} = `,
		...genCall([helper("createFor"), "undefined"], sourceExpr, blockFn, genCallback(keyProp), flags),
		...onResetCalls
	];
	function genCallback(expr) {
		if (!expr) return false;
		return context.withId(() => [
			...genAliasParams(value, key, index, context),
			" => (",
			...genExpression(expr, context),
			")"
		], genSimpleIdMap());
	}
	function genSimpleIdMap() {
		const idMap = {};
		const collect = (map) => map.forEach((_, id) => idMap[id] = null);
		collect(idToPathMap);
		collect(keyToPathMap);
		collect(indexToPathMap);
		return idMap;
	}
}
function genForFlags(onlyChild, component, isFragment, isSingleNode, once, slotRoot, wrappedRows) {
	let flags = 0;
	const names = [];
	if (onlyChild) {
		flags |= 1;
		names.push("FAST_REMOVE");
	}
	if (component) {
		flags |= 2;
		names.push("IS_COMPONENT");
	}
	if (isFragment) {
		flags |= 16;
		names.push("IS_FRAGMENT");
	}
	if (isSingleNode) {
		flags |= 8;
		names.push("IS_SINGLE_NODE");
	}
	if (once) {
		flags |= 4;
		names.push("ONCE");
	}
	if (slotRoot) {
		flags |= 32;
		names.push("SLOT_ROOT");
	}
	if (wrappedRows) {
		flags |= 64;
		names.push("WRAPPED_ROWS");
	}
	if (!flags) return;
	return genFlags(flags, names);
}
function isSingleNodeBlock(block) {
	const child = getSingleReturnedChild(block);
	return !!child && child.template != null;
}
function isFragmentBlock(block) {
	const child = getSingleReturnedChild(block);
	const operation = child && child.operation;
	if (!operation) return false;
	return operation.type === 12 || operation.type === 15 || operation.type === 16 || operation.type === 14 && !operation.once || operation.type === 11 && !!operation.dynamic && !operation.dynamic.isStatic;
}
function getSingleReturnedChild(block) {
	if (block.returns.length !== 1) return;
	const id = block.returns[0];
	for (const child of block.dynamic.children) if (child.id === id) return child;
}
function genAliasParams(value, key, index, context) {
	return genMulti([
		"(",
		")",
		", "
	], value ? genExpression(value, context, void 0, true) : key || index ? "_" : void 0, key ? genExpression(key, context, void 0, true) : index ? "__" : void 0, index && genExpression(index, context, void 0, true));
}
function parseValueDestructure(value, context) {
	const map = /* @__PURE__ */ new Map();
	if (value) {
		const rawValue = value.content;
		if (value.ast) walkIdentifiers(value.ast, (id, _, parentStack, ___, isLocal) => {
			if (isLocal) {
				let path = "";
				let isDynamic = false;
				let helper;
				let helperArgs;
				for (let i = 0; i < parentStack.length; i++) {
					const parent = parentStack[i];
					const child = parentStack[i + 1] || id;
					if (parent.type === "ObjectProperty" && parent.value === child) {
						if (parent.key.type === "StringLiteral") path += `[${JSON.stringify(parent.key.value)}]`;
						else if (parent.computed) {
							isDynamic = true;
							path += `[${rawValue.slice(parent.key.start - 1, parent.key.end - 1)}]`;
						} else path += `.${parent.key.name}`;
					} else if (parent.type === "ArrayPattern") {
						const index = parent.elements.indexOf(child);
						if (child.type === "RestElement") path += `.slice(${index})`;
						else path += `[${index}]`;
					} else if (parent.type === "ObjectPattern" && child.type === "RestElement") {
						helper = context.helper("getRestElement");
						helperArgs = "[" + parent.properties.filter((p) => p.type === "ObjectProperty").map((p) => {
							if (p.key.type === "StringLiteral") return JSON.stringify(p.key.value);
							else if (p.computed) {
								isDynamic = true;
								return rawValue.slice(p.key.start - 1, p.key.end - 1);
							} else return JSON.stringify(p.key.name);
						}).join(", ") + "]";
					}
					if (child.type === "AssignmentPattern" && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern" || parent.type === "ArrowFunctionExpression" && child.left === id)) {
						isDynamic = true;
						helper = context.helper("getDefaultValue");
						helperArgs = `() => (${rawValue.slice(child.right.start - 1, child.right.end - 1)})`;
					}
				}
				map.set(id.name, {
					path,
					dynamic: isDynamic,
					helper,
					helperArgs
				});
			}
		}, true);
		else if (rawValue) map.set(rawValue, null);
	}
	return map;
}
function buildDestructureIdMap(idToPathMap, baseAccessor, plugins) {
	const idMap = {};
	idToPathMap.forEach((pathInfo, id) => {
		let path = baseAccessor;
		if (pathInfo) {
			path = `${baseAccessor}${pathInfo.path}`;
			if (pathInfo.helper) {
				idMap[pathInfo.helper] = null;
				path = pathInfo.helperArgs ? `${pathInfo.helper}(${path}, ${pathInfo.helperArgs})` : `${pathInfo.helper}(${path})`;
			}
			if (pathInfo.dynamic) {
				const node = idMap[id] = createSimpleExpression(path);
				node.ast = (0, import_lib.parseExpression)(`(${path})`, getParserOptions(plugins));
			} else idMap[id] = path;
		} else idMap[id] = path;
	});
	return idMap;
}
function matchPatterns(render, keyProp, idMap, context) {
	const selectorPatterns = [];
	const keyOnlyBindingPatterns = [];
	let skippedEffectIndexes;
	if (keyProp === void 0) return {
		keyOnlyBindingPatterns,
		selectorPatterns,
		skippedEffectIndexes
	};
	const modelElements = new Set(render.operation.filter(isVModelOperation).map((oper) => oper.element));
	const lastOrderedProp = /* @__PURE__ */ new Map();
	for (let i = 0; i < render.effect.length; i++) {
		const effect = render.effect[i];
		if (effect.once) {
			for (const operation of effect.operations) if (operation.type === 3) lastOrderedProp.set(operation.element, i);
		}
	}
	for (let index = 0; index < render.effect.length; index++) {
		const effect = render.effect[index];
		if (effect.once || effect.operations.some((operation) => {
			var _lastOrderedProp$get;
			return isVModelListener(operation, modelElements) || operation.type === 3 && index < ((_lastOrderedProp$get = lastOrderedProp.get(operation.element)) !== null && _lastOrderedProp$get !== void 0 ? _lastOrderedProp$get : -1);
		})) continue;
		const selector = matchSelectorPattern(effect, keyProp.content, idMap, context);
		if (selector) {
			selectorPatterns.push(selector);
			skipEffect(index);
			continue;
		}
		const keyOnly = matchKeyOnlyBindingPattern(effect, keyProp.content);
		if (keyOnly) {
			keyOnlyBindingPatterns.push(keyOnly);
			skipEffect(index);
		}
	}
	return {
		keyOnlyBindingPatterns,
		selectorPatterns,
		skippedEffectIndexes
	};
	function skipEffect(index) {
		if (!skippedEffectIndexes) skippedEffectIndexes = /* @__PURE__ */ new Set();
		skippedEffectIndexes.add(index);
	}
}
function matchKeyOnlyBindingPattern(effect, key) {
	if (effect.expressions.length === 1) {
		const { ast, content } = effect.expressions[0];
		if (typeof ast === "object" && ast !== null) {
			if (isKeyOnlyBinding(ast, key, content)) return { effect };
		}
	}
}
function matchSelectorPattern(effect, key, idMap, context) {
	if (effect.expressions.length === 1) {
		const { ast, content } = effect.expressions[0];
		if (typeof ast === "object" && ast) {
			const matcheds = [];
			walk$2(ast, { enter(node) {
				if (typeof node === "object" && node && node.type === "BinaryExpression" && node.operator === "===" && node.left.type !== "PrivateName") {
					const { left, right } = node;
					for (const [a, b] of [[left, right], [right, left]]) {
						const aIsKey = content.slice(a.start - 1, a.end - 1) === key;
						const bIsKey = isKeyOnlyBinding(b, key, content);
						const bVars = analyzeVariableScopes(b, idMap);
						if (aIsKey && !bIsKey && !bVars.length) matcheds.push([a, b]);
					}
				}
			} });
			if (matcheds.length === 1) {
				const [key, selector] = matcheds[0];
				const content = effect.expressions[0].content;
				let hasExtraId = false;
				walkIdentifiers(ast, (id) => {
					if (id.start !== key.start && id.start !== selector.start) hasExtraId = true;
				}, false);
				if (!hasExtraId) {
					const name = content.slice(selector.start - 1, selector.end - 1);
					const selectorExpression = createSimpleExpression(name, false, selector.loc);
					selectorExpression.ast = (0, import_lib.parseExpression)(`(${name})`, getParserOptions(context.options.expressionPlugins));
					return {
						effect,
						selector: selectorExpression
					};
				}
			}
		}
	}
}
function analyzeVariableScopes(ast, idMap) {
	let locals = [];
	const ids = [];
	walkIdentifiers(ast, (id) => {
		ids.push(id);
	}, false);
	for (const id of ids) {
		if (isGloballyAllowed(id.name)) continue;
		if (idMap[id.name]) locals.push(id.name);
	}
	return locals;
}
function isKeyOnlyBinding(expr, key, source) {
	let only = true;
	walk$2(expr, { enter(node) {
		if (source.slice(node.start - 1, node.end - 1) === key) {
			this.skip();
			return;
		}
		if (node.type === "Identifier") only = false;
	} });
	return only;
}
//#endregion
//#region packages/compiler-vapor/src/generators/html.ts
function genSetHtml(oper, context) {
	const { helper } = context;
	const { value, element } = oper;
	return [NEWLINE, ...genCall(helper("setHtml"), `n${element}`, genExpression(value, context))];
}
//#endregion
//#region packages/compiler-vapor/src/generators/if.ts
function genIf(oper, context, isNested = false) {
	const { helper } = context;
	const { condition, positive, negative, once, slotRoot, index, blockShape } = oper;
	const [frag, push] = buildCodeFragment();
	const flags = genIfFlags(blockShape, once, slotRoot, negative ? index : void 0);
	const conditionExpr = [
		"() => (",
		...genExpression(condition, context),
		")"
	];
	let positiveArg = genBlock(positive, context);
	let negativeArg = false;
	if (negative) {
		if (negative.type === 1) negativeArg = genBlock(negative, context);
		else negativeArg = ["() => ", ...genIf(negative, context, true)];
	}
	if (!isNested) push(NEWLINE, `const n${oper.id} = `);
	push(...genCall(helper("createIf"), conditionExpr, positiveArg, negativeArg, flags));
	return frag;
}
function genIfFlags(blockShape, once, slotRoot, index) {
	let flags = blockShape;
	if (slotRoot) flags |= 128;
	if (once) flags |= 16;
	else if (index !== void 0) flags |= index + 1 << 8;
	if (flags === 1) return false;
	return genFlags(flags, genIfFlagNames(once, slotRoot, index, blockShape));
}
function genIfFlagNames(once, slotRoot, index, blockShape) {
	const names = [`TRUE_${genBlockShapeName(blockShape)}`];
	const falseShape = blockShape >> 2;
	const hasFalseBranch = (falseShape & 3) !== 0;
	if (hasFalseBranch) names.push(`FALSE_${genBlockShapeName(falseShape)}`);
	if (blockShape & 32) names.push("TRUE_NO_SCOPE");
	if (hasFalseBranch && blockShape & 64) names.push("FALSE_NO_SCOPE");
	if (once) names.push("ONCE");
	if (slotRoot) names.push("SLOT_ROOT");
	if (!once && index !== void 0) names.push(`KEYED_INDEX_${index}`);
	return names;
}
function genBlockShapeName(flags) {
	switch (flags & 3) {
		case 0: return "EMPTY";
		case 1: return "SINGLE_ROOT";
		case 2: return "MULTI_ROOT";
	}
	return "UNKNOWN";
}
//#endregion
//#region packages/compiler-vapor/src/generators/prop.ts
const helpers = {
	setElementText: { name: "setElementText" },
	setHtml: { name: "setHtml" },
	setClass: { name: "setClass" },
	setClassName: { name: "setClassName" },
	setStyle: { name: "setStyle" },
	setValue: { name: "setValue" },
	setAttr: {
		name: "setAttr",
		needKey: true
	},
	setProp: {
		name: "setProp",
		needKey: true
	},
	setDOMProp: {
		name: "setDOMProp",
		needKey: true
	}
};
function genSetProp(oper, context) {
	const { helper } = context;
	const { prop: { key, values, modifier }, tag, isSVG } = oper;
	if (!modifier && isOn(key.content)) return genSetListener(oper, context);
	const resolvedHelper = getRuntimeHelper(tag, isSVG, key.content, modifier);
	if (key.content === "class" && !resolvedHelper.isSVG && resolvedHelper.name === "setClass") {
		const className = genSetClassName(oper, context);
		if (className) return className;
	}
	const propValue = genPropValue(values, context);
	return [NEWLINE, ...genCall([helper(resolvedHelper.name), null], `n${oper.element}`, resolvedHelper.needKey ? genExpression(key, context) : false, propValue, resolvedHelper.isSVG && "true")];
}
const optionsModifierRE = /(Once|Passive|Capture)$/;
const optionsModifierEventRE = /^on:?(?:Once|Passive|Capture)$/;
function genSetListener(oper, context) {
	const { helper } = context;
	const { element, effect, prop } = oper;
	const value = genPropValue(prop.values, context);
	if (effect) return [NEWLINE, ...genCall(helper("setListener"), `n${element}`, JSON.stringify(prop.key.content), value)];
	let name = prop.key.content;
	const options = [];
	let m;
	while ((m = name.match(optionsModifierRE)) && !optionsModifierEventRE.test(name)) {
		name = name.slice(0, name.length - m[1].length);
		options.push([`${m[1].toLowerCase()}: true`]);
	}
	const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
	return [NEWLINE, ...genCall(helper("on"), `n${element}`, JSON.stringify(event), value, options.length ? genMulti(DELIMITERS_OBJECT, ...options) : void 0)];
}
const MAX_CLASS_NAME_ENTRIES = 31;
function genSetClassName(oper, context) {
	const info = resolveClassName(oper.prop.values, context);
	if (!info) return;
	const { helper } = context;
	const flags = genClassFlags(info.entries, context);
	const classFragments = info.entries.map((entry) => JSON.stringify(!info.prefix && info.entries.length === 1 ? entry.className : ` ${entry.className}`));
	const fragments = classFragments.length === 1 ? classFragments[0] : genMulti(DELIMITERS_ARRAY, ...classFragments);
	return [NEWLINE, ...genCall([helper("setClassName"), "\"\""], `n${oper.element}`, flags, fragments, info.prefix && JSON.stringify(info.prefix), info.suffix && JSON.stringify(info.suffix))];
}
function resolveClassName(values, context) {
	let prefix = "";
	let suffix = "";
	const entries = [];
	let sawDynamic = false;
	let sawSuffix = false;
	for (const rawValue of values) {
		const value = context.getExpressionReplacement(rawValue);
		const staticValue = getLiteralExpressionValue(value, true);
		if (staticValue != null) {
			const normalized = normalizeClass(staticValue);
			if (normalized) {
				if (sawSuffix) suffix = appendClass$1(suffix, normalized);
				else if (sawDynamic) {
					sawSuffix = true;
					suffix = appendClass$1(suffix, normalized);
				} else prefix = appendClass$1(prefix, normalized);
			}
			continue;
		}
		const ast = value.ast;
		if (!ast || sawSuffix) return;
		sawDynamic = true;
		if (ast.type === "ObjectExpression") {
			if (!resolveObjectClassName(value, ast, entries, context)) return;
		} else if (ast.type === "ConditionalExpression") {
			if (!resolveConditionalClassName(value, ast, entries, context)) return;
		} else return;
	}
	return entries.length && entries.length <= MAX_CLASS_NAME_ENTRIES ? {
		prefix,
		suffix,
		entries
	} : void 0;
}
function resolveObjectClassName(source, ast, entries, context) {
	for (const prop of ast.properties) {
		if (prop.type !== "ObjectProperty" || prop.computed) return false;
		const rawClassName = getObjectPropertyName$1(prop);
		if (rawClassName == null) return false;
		const className = normalizeClass(rawClassName);
		if (!className) continue;
		const value = getBooleanValue(prop.value);
		entries.push({
			className,
			value,
			condition: value == null ? createSubExpression(source, prop.value, context) : void 0
		});
	}
	return true;
}
function resolveConditionalClassName(source, ast, entries, context) {
	const consequent = getStringClassValue(ast.consequent);
	const alternate = getStringClassValue(ast.alternate);
	if (consequent && alternate === "") {
		entries.push({
			className: consequent,
			condition: createSubExpression(source, ast.test, context)
		});
		return true;
	} else if (alternate && consequent === "") {
		entries.push({
			className: alternate,
			condition: createSubExpression(source, ast.test, context),
			negate: true
		});
		return true;
	}
	return false;
}
function genClassFlags(entries, context) {
	const values = [];
	entries.forEach((entry, index) => {
		if (index) values.push(" | ");
		const bit = 1 << index;
		if (entry.value != null) {
			values.push(entry.value ? String(bit) : "0");
			return;
		}
		values.push("((", ...genExpression(entry.condition, context), ")", entry.negate ? ` ? 0 : ${bit}` : ` ? ${bit} : 0`, ")");
	});
	return values;
}
function appendClass$1(base, value) {
	return base ? value ? `${base} ${value}` : base : value;
}
function getObjectPropertyName$1(prop) {
	const key = prop.key;
	if (key.type === "Identifier") return key.name;
	else if (key.type === "StringLiteral") return key.value;
	else if (key.type === "NumericLiteral") return String(key.value);
}
function getStringClassValue(node) {
	if (node.type === "StringLiteral") return normalizeClass(node.value);
	else if (node.type === "TemplateLiteral" && node.expressions.length === 0) return normalizeClass(node.quasis[0].value.cooked || "");
	else if (node.type === "NullLiteral" || node.type === "BooleanLiteral" && !node.value) return "";
}
function getBooleanValue(node) {
	if (node.type === "BooleanLiteral") return node.value;
}
function createSubExpression(source, node, context) {
	const start = node.start == null ? 0 : node.start - 1;
	const end = node.end == null ? source.content.length : node.end - 1;
	const content = source.content.slice(start, end);
	const expression = createSimpleExpression(content, false, {
		start: advancePositionWithClone(source.loc.start, source.content, start),
		end: advancePositionWithClone(source.loc.start, source.content, end),
		source: content
	});
	expression.ast = isSimpleIdentifier(content) ? null : (0, import_lib.parseExpression)(`(${content})`, getParserOptions(context.options.expressionPlugins));
	return expression;
}
function genDynamicProps$1(oper, context) {
	const { helper } = context;
	const values = oper.props.map((props) => {
		if (Array.isArray(props)) return genLiteralObjectProps(props, context);
		if (props.kind === 1) return genLiteralObjectProps([props], context);
		const value = genExpression(props.value, context);
		return props.handler ? genCall(helper("toHandlers"), value, "true") : value;
	});
	return [NEWLINE, ...genCall(helper("setDynamicProps"), `n${oper.element}`, genMulti(DELIMITERS_ARRAY, ...values), genDynamicPropNames$1(oper, context), oper.isSVG && "true")];
}
function genDynamicPropNames$1(oper, context) {
	const { bindingMetadata } = context.options;
	const names = oper.props.flatMap((props) => Array.isArray(props) ? props.filter(({ key, values, modifier, handler }) => key.isStatic && modifier !== "." && !handler && key.content !== "class" && key.content !== "style" && values.some((v) => !v.isStatic && !isConstantBinding$1(v, bindingMetadata))).map((prop) => getStaticPropKeyName(prop)) : []);
	if (!names.length) return false;
	const json = JSON.stringify(names);
	let id = context.dynamicPropNames.get(json);
	if (!id) context.dynamicPropNames.set(json, id = context.kName(context.dynamicPropNames.size));
	return id;
}
function genLiteralObjectProps(props, context) {
	const entries = [];
	const listeners = createHandlerGroups(entries);
	for (const prop of props) if (isListenerProp(prop)) listeners.add(getStaticPropKeyName(prop, true), genPropKey(prop, context, true), prop.handler ? genEventHandler(context, prop.values, prop.handlerModifiers) : genPropValue(prop.values, context));
	else entries.push([
		...genPropKey(prop, context),
		`: `,
		...genPropValue(prop.values, context)
	]);
	listeners.fill();
	return genMulti(DELIMITERS_OBJECT, ...entries);
}
function isListenerProp(prop) {
	return prop.handler || !prop.modifier && !prop.model && prop.key.isStatic && isOn(prop.key.content);
}
function createHandlerGroups(entries, prefix = "", delimiters = DELIMITERS_ARRAY) {
	const groups = /* @__PURE__ */ new Map();
	return {
		add(name, keyFrag, handler) {
			let group = groups.get(name);
			if (!group) {
				groups.set(name, group = {
					keyFrag,
					handlers: [],
					index: entries.length
				});
				entries.push([]);
			}
			group.handlers.push(handler);
		},
		fill() {
			for (const { keyFrag, handlers, index } of groups.values()) entries[index] = [
				...keyFrag,
				": ",
				prefix,
				...handlers.length > 1 ? genMulti(delimiters, ...handlers) : handlers[0]
			];
		}
	};
}
function getStaticPropKeyName({ key, modifier, handler, handlerModifiers }, preserveCase = false) {
	return (handler ? preserveCase && /[A-Z]/.test(key.content) ? `on:${key.content}` : toHandlerKey(camelize(key.content)) : (modifier || "") + key.content) + getHandlerModifierPostfix(handlerModifiers);
}
function getHandlerModifierPostfix(handlerModifiers) {
	return handlerModifiers && handlerModifiers.options ? handlerModifiers.options.map(capitalize).join("") : "";
}
function genPropKey(prop, context, preserveCase = false) {
	const { key: node, modifier, runtimeCamelize, handler, handlerModifiers, model } = prop;
	const { helper } = context;
	const handlerModifierPostfix = getHandlerModifierPostfix(handlerModifiers);
	if (node.isStatic) {
		const keyName = getStaticPropKeyName(prop, preserveCase);
		return [[
			isSimpleIdentifier(keyName) ? keyName : JSON.stringify(keyName),
			-2,
			node.loc
		]];
	}
	let key = genExpression(node, context);
	if (runtimeCamelize) {
		key.push(" || \"\"");
		key = genCall(helper("camelize"), key);
	} else if (modifier) key = [
		"(",
		...key,
		" || \"\"",
		")"
	];
	else if (!handler && !model) key = node.ast === null ? [...key, " || \"\""] : [
		"(",
		...key,
		") || \"\""
	];
	if (handler) key = genCall(helper("toHandlerKey"), key);
	return [
		"[",
		modifier && `${JSON.stringify(modifier)} + `,
		...key,
		handlerModifierPostfix ? ` + ${JSON.stringify(handlerModifierPostfix)}` : void 0,
		"]"
	];
}
function genPropValue(values, context) {
	if (values.length === 1) return genExpression(values[0], context);
	return genMulti(DELIMITERS_ARRAY, ...values.map((expr) => genExpression(expr, context)));
}
function getRuntimeHelper(tag, isSVG, key, modifier) {
	const tagName = tag.toUpperCase();
	if (modifier) {
		if (modifier === ".") return getSpecialHelper(key, tagName, isSVG) || helpers.setDOMProp;
		else return isSVG ? extend({ isSVG: true }, helpers.setAttr) : helpers.setAttr;
	}
	const helper = getSpecialHelper(key, tagName, isSVG);
	if (helper) return helper;
	if (/aria[A-Z]/.test(key)) return helpers.setDOMProp;
	if (isSVG) return extend({ isSVG: true }, helpers.setAttr);
	if (shouldSetAsAttr(tagName, key) || key.includes("-")) return helpers.setAttr;
	return helpers.setProp;
}
function getSpecialHelper(keyName, tagName, isSVG) {
	if (keyName === "value" && canSetValueDirectly(tagName)) return helpers.setValue;
	else if (keyName === "class") return extend({ isSVG }, helpers.setClass);
	else if (keyName === "style") return helpers.setStyle;
	else if (keyName === "innerHTML") return helpers.setHtml;
	else if (keyName === "textContent") return helpers.setElementText;
}
//#endregion
//#region packages/compiler-vapor/src/generators/templateRef.ts
const setTemplateRefIdent = `_setTemplateRef`;
function genSetTemplateRef(oper, context) {
	const [refValue, refKey] = genRefValue(oper.value, context);
	if (!oper.effect && !oper.refFor && oper.value.isStatic) return genSetStaticTemplateRef(oper, refValue, refKey, context);
	context.needsTemplateRefSetter = true;
	return [NEWLINE, ...genCall(setTemplateRefIdent, `n${oper.element}`, refValue, oper.refFor && "true", refKey)];
}
function genSetStaticTemplateRef(oper, refValue, refKey, context) {
	return [NEWLINE, ...genCall(context.helper("setStaticTemplateRef"), `n${oper.element}`, refValue, oper.refFor && "true", refKey)];
}
function genSetTemplateRefBinding(oper, context) {
	const [refValue, refKey] = genRefValue(oper.value, context);
	return [NEWLINE, ...genCall([context.helper("setTemplateRefBinding"), "undefined"], `n${oper.element}`, ["() => ", ...refValue], ...oper.refFor || refKey ? [oper.refFor && "true", refKey] : [])];
}
function genRefValue(value, context) {
	if (value && context.options.inline) {
		const binding = context.options.bindingMetadata[value.content];
		if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") return [[value.content], JSON.stringify(value.content)];
	}
	return [genExpression(value, context)];
}
//#endregion
//#region packages/compiler-vapor/src/generators/text.ts
function genSetText(oper, context) {
	const { helper } = context;
	const { element, values, generated } = oper;
	const texts = combineValues(values, context);
	return [NEWLINE, ...genCall(helper("setText"), `${generated ? "x" : "n"}${element}`, texts)];
}
function combineValues(values, context) {
	return values.flatMap((value, i) => {
		let exp = genExpression(value, context);
		if (getLiteralExpressionValue(value, true) == null) exp = genCall(context.helper("toDisplayString"), exp);
		if (i > 0) exp.unshift(" + ");
		return exp;
	});
}
function genGetTextChild(oper, context) {
	return [NEWLINE, `const x${oper.parent} = ${context.helper("txt")}(n${oper.parent})`];
}
//#endregion
//#region packages/compiler-vapor/src/generators/modifier.ts
function genDirectiveModifiers(modifiers) {
	return modifiers.map((value) => `${isSimpleIdentifier(value) ? value : JSON.stringify(value)}: true`).join(", ");
}
//#endregion
//#region packages/compiler-vapor/src/generators/vModel.ts
const helperMap = {
	text: "applyTextModel",
	radio: "applyRadioModel",
	checkbox: "applyCheckboxModel",
	select: "applySelectModel",
	dynamic: "applyDynamicModel"
};
function genVModel(oper, context) {
	const { modelType, element, dir: { exp, modifiers } } = oper;
	return genCall(context.helper(helperMap[modelType]), `n${element}`, [
		`() => (`,
		...genExpression(exp, context),
		`)`
	], genModelHandler(exp, context), modifiers.length ? `{ ${genDirectiveModifiers(modifiers.map((e) => e.content))} }` : void 0);
}
function genModelHandler(exp, context) {
	return [
		`${context.options.isTS ? `(_value: any)` : `_value`} => (`,
		...genExpression(exp, context, "_value"),
		")"
	];
}
//#endregion
//#region packages/compiler-vapor/src/generators/component.ts
function genStaticModifierPropKey(name) {
	const key = getModifierPropName(name);
	return [isSimpleIdentifier(key) ? key : JSON.stringify(key)];
}
function genCreateComponent(operation, context) {
	const { helper } = context;
	const singleUseAssetComponentNames = context.singleUseAssetComponentNames;
	const useAssetComponentHelper = operation.asset && !operation.dynamic && context.block === context.ir.block && !!singleUseAssetComponentNames && singleUseAssetComponentNames.has(operation.tag);
	const maybeSelfReference = useAssetComponentHelper && operation.tag.endsWith("__self");
	const tag = genTag();
	const { root, props, slots, once, slotRoot } = operation;
	const isRuntimeDynamicComponent = !!(operation.dynamic && !operation.dynamic.isStatic);
	const dynamicComponentFlags = isRuntimeDynamicComponent ? genDynamicComponentFlags(root, once, slotRoot, operation.ns) : false;
	const nsArg = !isRuntimeDynamicComponent && (operation.useCreateElement || operation.asset || !!operation.dynamic) && operation.ns ? String(operation.ns) : false;
	const slotDeclarations = [];
	const rawSlots = genRawSlots(slots, context, slotDeclarations);
	const [ids, handlers] = processInlineHandlers(props, context);
	const rawProps = context.withId(() => genRawProps(props, context, true), ids);
	const inlineHandlers = handlers.reduce((acc, { name, value }) => {
		const handler = genEventHandler(context, [value]);
		return [
			...acc,
			`const ${name} = `,
			...handler,
			NEWLINE
		];
	}, []);
	return [
		NEWLINE,
		...inlineHandlers,
		...slotDeclarations.length ? genMulti([
			"let ",
			NEWLINE,
			", "
		], ...slotDeclarations) : [],
		`const n${operation.id} = `,
		...genCall(isRuntimeDynamicComponent ? helper("createDynamicComponent") : operation.useCreateElement ? helper("createPlainElement") : useAssetComponentHelper ? helper("createAssetComponent") : operation.asset ? helper("createComponentWithFallback") : helper("createComponent"), tag, rawProps, rawSlots, isRuntimeDynamicComponent ? dynamicComponentFlags : root ? "true" : false, isRuntimeDynamicComponent ? operation.key && [
			"() => (",
			...genExpression(operation.key, context),
			")"
		] : once && "true", useAssetComponentHelper ? maybeSelfReference && "true" : nsArg, useAssetComponentHelper && nsArg)
	];
	function genTag() {
		if (operation.useCreateElement) return JSON.stringify(operation.tag);
		else if (operation.dynamic) {
			if (operation.dynamic.isStatic) return genCall(helper("resolveDynamicComponent"), genExpression(operation.dynamic, context));
			else return [
				"() => (",
				...genExpression(operation.dynamic, context),
				")"
			];
		} else if (useAssetComponentHelper) {
			const name = maybeSelfReference ? operation.tag.slice(0, -6) : operation.tag;
			return JSON.stringify(name);
		} else if (operation.asset) return toValidAssetId(operation.tag, "component");
		else {
			const { tag } = operation;
			const builtInTag = isBuiltInComponent(tag);
			if (builtInTag) {
				helper(builtInTag);
				return `_${builtInTag}`;
			}
			return genExpression(extend(createSimpleExpression(tag, false), { ast: null }), context);
		}
	}
}
function genDynamicComponentFlags(root, once, slotRoot, ns) {
	let flags = 0;
	const names = [];
	if (root) {
		flags |= 1;
		names.push("SINGLE_ROOT");
	}
	if (once) {
		flags |= 2;
		names.push("ONCE");
	}
	if (slotRoot) {
		flags |= 4;
		names.push("SLOT_ROOT");
	}
	if (ns === 1) {
		flags |= 8;
		names.push("NS_SVG");
	} else if (ns === 2) {
		flags |= 16;
		names.push("NS_MATHML");
	}
	if (!flags) return false;
	return genFlags(flags, names);
}
function getUniqueHandlerName(context, name) {
	const { seenInlineHandlerNames } = context;
	name = genVarName(name);
	const count = seenInlineHandlerNames[name] || 0;
	seenInlineHandlerNames[name] = count + 1;
	return count === 0 ? name : `${name}${count}`;
}
function processInlineHandlers(props, context) {
	const ids = Object.create(null);
	const handlers = [];
	const staticProps = props[0];
	if (isArray$3(staticProps)) for (let i = 0; i < staticProps.length; i++) {
		const prop = staticProps[i];
		if (!prop.handler) continue;
		prop.values.forEach((value, i) => {
			if (!isMemberExpression$1(value, context.options)) {
				const name = getUniqueHandlerName(context, `_on_${prop.key.content.replace(/-/g, "_")}`);
				handlers.push({
					name,
					value
				});
				ids[name] = null;
				prop.values[i] = extend({ ast: null }, createSimpleExpression(name));
			}
		});
	}
	return [ids, handlers];
}
function genRawProps(props, context, directStaticLiteralProps = false) {
	const staticProps = props[0];
	if (isArray$3(staticProps)) {
		if (!staticProps.length && props.length === 1) return;
		return genStaticProps(staticProps, context, genDynamicProps(props.slice(1), context, directStaticLiteralProps), directStaticLiteralProps);
	} else if (props.length) return genStaticProps([], context, genDynamicProps(props, context, directStaticLiteralProps), directStaticLiteralProps);
}
function genStaticProps(props, context, dynamicProps, directStaticLiteralProps = false) {
	const args = [];
	const handlerGroups = createHandlerGroups(args, "() => ", DELIMITERS_ARRAY_NEWLINE);
	for (const prop of props) {
		if (isListenerProp(prop)) {
			if (!prop.key.isStatic) {
				args.push(genProp(prop, context, true));
				continue;
			}
			const keyName = getStaticPropKeyName(prop);
			const keyFrag = genPropKey(prop, context);
			if (!prop.handler) {
				handlerGroups.add(keyName, keyFrag, [
					"(",
					...genPropValue(prop.values, context),
					")"
				]);
				continue;
			}
			if (!!prop.handlerModifiers && (prop.handlerModifiers.keys.length > 0 || prop.handlerModifiers.nonKeys.length > 0) || prop.values.length <= 1) {
				const handlerExp = genEventHandler(context, prop.values, prop.handlerModifiers, { asComponentProp: true });
				handlerGroups.add(keyName, keyFrag, handlerExp);
			} else for (const value of prop.values) {
				const handlerExp = genEventHandler(context, [value], prop.handlerModifiers, { asComponentProp: true });
				handlerGroups.add(keyName, keyFrag, handlerExp);
			}
			continue;
		}
		args.push(genProp(prop, context, true, true, directStaticLiteralProps && isDirectStaticLiteralProp(prop, context)));
		if (prop.model) {
			if (prop.key.isStatic) {
				const keyName = `onUpdate:${camelize(prop.key.content)}`;
				const keyFrag = [JSON.stringify(keyName)];
				handlerGroups.add(keyName, keyFrag, genModelHandler(prop.values[0], context));
			} else {
				const keyFrag = [
					"[\"onUpdate:\" + ",
					...genExpression(prop.key, context),
					"]"
				];
				args.push([
					...keyFrag,
					": () => ",
					...genModelHandler(prop.values[0], context)
				]);
			}
			const { key, modelModifiers } = prop;
			if (modelModifiers && modelModifiers.length) {
				const modifiersKey = key.isStatic ? genStaticModifierPropKey(key.content) : [
					"[",
					...genExpression(key, context),
					" + \"Modifiers\"]"
				];
				const modifiersVal = genDirectiveModifiers(modelModifiers);
				args.push([...modifiersKey, directStaticLiteralProps ? `: { ${modifiersVal} }` : `: () => ({ ${modifiersVal} })`]);
			}
		}
	}
	handlerGroups.fill();
	if (dynamicProps) args.push([`$: `, ...dynamicProps]);
	return genMulti(args.length > 1 ? DELIMITERS_OBJECT_NEWLINE : DELIMITERS_OBJECT, ...args);
}
function genDynamicProps(props, context, directStaticLiteralProps = false) {
	const { helper } = context;
	const frags = [];
	for (const p of props) {
		let expr;
		if (isArray$3(p)) {
			if (p.length) frags.push(genStaticProps(p, context, void 0, directStaticLiteralProps));
			continue;
		} else if (p.kind === 1) {
			if (p.model) {
				const entries = [genProp(p, context)];
				const updateKey = p.key.isStatic ? [JSON.stringify(`onUpdate:${camelize(p.key.content)}`)] : [
					"[\"onUpdate:\" + ",
					...genExpression(p.key, context),
					"]"
				];
				entries.push([
					...updateKey,
					": ",
					...genModelHandler(p.values[0], context)
				]);
				const { modelModifiers } = p;
				if (modelModifiers && modelModifiers.length) {
					const modifiersKey = p.key.isStatic ? genStaticModifierPropKey(p.key.content) : [
						"[",
						...genExpression(p.key, context),
						" + \"Modifiers\"]"
					];
					const modifiersVal = genDirectiveModifiers(modelModifiers);
					entries.push([...modifiersKey, `: { ${modifiersVal} }`]);
				}
				expr = genMulti(DELIMITERS_OBJECT_NEWLINE, ...entries);
			} else expr = genMulti(DELIMITERS_OBJECT, genProp(p, context, false, false));
		} else {
			expr = genExpression(p.value, context);
			if (p.handler) expr = genCall(helper("toHandlers"), expr);
		}
		frags.push([
			"() => (",
			...expr,
			")"
		]);
	}
	if (frags.length) return genMulti(DELIMITERS_ARRAY_NEWLINE, ...frags);
}
function genProp(prop, context, isStatic, wrapHandler = true, directStaticLiteral = false) {
	let values = genPropValue(prop.values, context);
	if (prop.toDisplayString) values = genCall(context.helper("toDisplayString"), values);
	return [
		...genPropKey(prop, context),
		": ",
		...prop.handler ? genEventHandler(context, prop.values, prop.handlerModifiers, {
			asComponentProp: true,
			extraWrap: wrapHandler
		}) : isStatic ? directStaticLiteral ? values : [
			"() => (",
			...values,
			")"
		] : values
	];
}
/**
* Static literal values are safe to emit directly because reading them cannot
* touch reactive state. Keep handlers, v-model values, and dynamic expressions
* as getter sources to preserve lazy access and merge semantics.
*/
function isDirectStaticLiteralProp(prop, context) {
	return prop.key.isStatic && prop.values.length === 1 && !prop.handler && !prop.model && isDirectConstantValue(prop.values[0], context);
}
function isDirectConstantValue(value, context) {
	value = context.getExpressionReplacement(value);
	if (value.isStatic) return true;
	const ast = value.ast;
	if (ast === null) return value.content === "true" || value.content === "false" || value.content === "null" || value.content === "undefined";
	if (!ast) return false;
	return isDirectConstantAst(ast);
}
function isDirectConstantAst(node) {
	switch (node.type) {
		case "StringLiteral":
		case "NumericLiteral":
		case "BooleanLiteral":
		case "NullLiteral":
		case "BigIntLiteral": return true;
		case "Identifier": return node.name === "undefined";
		case "TemplateLiteral": return node.expressions.every((expression) => isDirectTemplateConstantAst(expression));
		case "ArrayExpression": return node.elements.every((element) => element === null || element.type !== "SpreadElement" && isDirectConstantAst(element));
		case "ObjectExpression": return node.properties.every((prop) => prop.type === "ObjectProperty" && !prop.computed && isDirectConstantAst(prop.value));
	}
	return false;
}
function isDirectTemplateConstantAst(node) {
	switch (node.type) {
		case "StringLiteral":
		case "NumericLiteral":
		case "BooleanLiteral":
		case "NullLiteral":
		case "BigIntLiteral": return true;
		case "Identifier": return node.name === "undefined";
		case "TemplateLiteral": return node.expressions.every((expression) => isDirectTemplateConstantAst(expression));
	}
	return false;
}
function genRawSlots(slots, context, slotDeclarations) {
	if (!slots.length) return;
	slots = [...slots.filter((slot) => !isConditionalOrLoopSlot(slot)), ...slots.filter(isConditionalOrLoopSlot)];
	const staticSlots = slots[0];
	if (staticSlots.slotType === 0) {
		const defaultSlot = getSingleDefaultSlot(staticSlots);
		if (defaultSlot && slots.length === 1) return genSlotBlockWithProps(defaultSlot, context);
		return genStaticSlots(staticSlots, context, slotDeclarations, slots.length > 1 ? slots.slice(1) : void 0);
	} else return genStaticSlots({
		slotType: 0,
		slots: {}
	}, context, slotDeclarations, slots);
}
function isConditionalOrLoopSlot(slot) {
	return slot.slotType === 3 || slot.slotType === 2;
}
function getSingleDefaultSlot({ slots }) {
	const names = Object.keys(slots);
	return names.length === 1 && names[0] === "default" ? slots.default : void 0;
}
function genStaticSlots({ slots }, context, slotDeclarations, dynamicSlots) {
	const args = Object.keys(slots).map((name) => [`${JSON.stringify(name)}: `, ...genSlotBlockWithProps(slots[name], context)]);
	if (dynamicSlots) args.push([`$: `, ...genDynamicSlots(dynamicSlots, context, slotDeclarations)]);
	return genMulti(DELIMITERS_OBJECT_NEWLINE, ...args);
}
function genDynamicSlots(slots, context, slotDeclarations) {
	return genMulti(DELIMITERS_ARRAY_NEWLINE, ...slots.map((slot) => slot.slotType === 0 ? genStaticSlots(slot, context, slotDeclarations) : slot.slotType === 4 ? slot.slots.content : genDynamicSlot(slot, context, slotDeclarations, slot.slotType !== 2)));
}
function genDynamicSlot(slot, context, slotDeclarations, withFunction = false) {
	let frag;
	switch (slot.slotType) {
		case 1:
			frag = genBasicDynamicSlot(slot, context, slotDeclarations);
			break;
		case 2:
			frag = genLoopSlot(slot, context);
			break;
		case 3: frag = genConditionalSlot(slot, context, slotDeclarations);
	}
	if (!withFunction) return frag;
	return [
		"() => (",
		...frag,
		")"
	];
}
function genBasicDynamicSlot(slot, context, slotDeclarations) {
	const { name, fn } = slot;
	const slotName = context.getUniqueLocalName("s");
	slotDeclarations.push(slotName);
	return genMulti(DELIMITERS_OBJECT_NEWLINE, ["name: ", ...genExpression(name, context)], [
		`fn: ${slotName} || (${slotName} = `,
		...genSlotBlockWithProps(fn, context, false),
		")"
	]);
}
function genLoopSlot(slot, context) {
	const { name, fn, loop, keyProp } = slot;
	const { value, key, index, source } = loop;
	const plugins = context.options.expressionPlugins;
	const idToPathMap = parseValueDestructure(value, context);
	const keyToPathMap = parseValueDestructure(key, context);
	const indexToPathMap = parseValueDestructure(index, context);
	const [depth, exitScope] = context.enterScope();
	const itemVar = `_for_item${depth}`;
	const idMap = buildDestructureIdMap(idToPathMap, `${itemVar}.value`, plugins);
	idMap[itemVar] = null;
	const args = [itemVar];
	if (key) {
		const keyVar = `_for_key${depth}`;
		args.push(keyVar);
		Object.assign(idMap, buildDestructureIdMap(keyToPathMap, `${keyVar}.value`, plugins));
		idMap[keyVar] = null;
	} else if (index) args.push("_");
	if (index) {
		const indexVar = `_for_index${depth}`;
		args.push(indexVar);
		Object.assign(idMap, buildDestructureIdMap(indexToPathMap, `${indexVar}.value`, plugins));
		idMap[indexVar] = null;
	}
	const renderSlot = [
		...genMulti([
			"(",
			")",
			", "
		], ...args),
		" => ",
		...context.withId(() => genSlotBlockWithProps(fn, context, false), idMap)
	];
	exitScope();
	const rawIdMap = {};
	const collect = (map) => map.forEach((_, id) => rawIdMap[id] = null);
	collect(idToPathMap);
	collect(keyToPathMap);
	collect(indexToPathMap);
	const rawParams = context.withId(() => genAliasParams(value, key, index, context), rawIdMap);
	const getName = [
		...rawParams,
		" => (",
		...context.withId(() => genExpression(name, context), rawIdMap),
		")"
	];
	const getKey = keyProp && [
		...rawParams,
		" => (",
		...context.withId(() => genExpression(keyProp, context), rawIdMap),
		")"
	];
	return [...genCall(context.helper("createForSlots"), [
		"() => (",
		...genExpression(source, context),
		")"
	], renderSlot, getName, getKey)];
}
function genConditionalSlot(slot, context, slotDeclarations) {
	const { condition, positive, negative } = slot;
	return [
		...genExpression(condition, context),
		INDENT_START,
		NEWLINE,
		"? ",
		...genDynamicSlot(positive, context, slotDeclarations),
		NEWLINE,
		": ",
		...negative ? genDynamicSlot(negative, context, slotDeclarations) : ["void 0"],
		INDENT_END
	];
}
function genSlotBlockWithProps(oper, context, emitNonStableFlag = true) {
	let propsName;
	let exitScope;
	let depth;
	const { props } = oper;
	const idToPathMap = props ? parseValueDestructure(props, context) : /* @__PURE__ */ new Map();
	if (props) {
		if (props.ast) {
			[depth, exitScope] = context.enterScope();
			propsName = `_slotProps${depth}`;
		} else propsName = props.content;
	}
	const idMap = idToPathMap.size ? buildDestructureIdMap(idToPathMap, propsName || "", context.options.expressionPlugins) : {};
	if (propsName) idMap[propsName] = null;
	const exitSlotBlock = context.enterSlotBlock();
	const hasStableRoot = hasStableSlotRoot(oper, context);
	if (!hasStableRoot) markSlotRootOperations(oper, context);
	let blockFn = context.withId(() => genBlock(oper, context, propsName ? [propsName] : []), idMap);
	if (emitNonStableFlag && !hasStableRoot) blockFn = genCall(context.helper("extend"), blockFn, [`{ _: ${genFlags(1, ["NON_STABLE"])} }`]);
	exitSlotBlock();
	exitScope && exitScope();
	return blockFn;
}
//#endregion
//#region packages/compiler-vapor/src/generators/slotOutlet.ts
function genSlotOutlet(oper, context) {
	const { helper } = context;
	const { id, name, fallback, flags } = oper;
	const [frag, push] = buildCodeFragment();
	let fallbackArg;
	if (fallback) {
		if (context.inSlotBlock) markSlotRootOperations(fallback, context);
		fallbackArg = genBlock(fallback, context);
	}
	const createSlot = helper("createSlot");
	const rawPropsArg = genRawProps(oper.props, context, true);
	const nameArg = name.isStatic && name.content === "default" && !rawPropsArg && !fallbackArg && !flags ? void 0 : name.isStatic ? genExpression(name, context) : [
		"() => (",
		...genExpression(name, context),
		")"
	];
	push(NEWLINE, `const n${id} = `, ...genCall(createSlot, nameArg, rawPropsArg, fallbackArg, genSlotFlags(flags)));
	return frag;
}
function genSlotFlags(flags) {
	if (!flags) return;
	const names = [];
	if (flags & 1) names.push("NO_SLOTTED");
	if (flags & 2) names.push("ONCE");
	if (flags & 4) names.push("FORWARDED");
	if (flags & 8) names.push("SHARED_FALLBACK");
	return genFlags(flags, names);
}
//#endregion
//#region packages/compiler-vapor/src/generators/vShow.ts
function genVShow(oper, context) {
	const { element } = oper;
	return genCall(context.helper("applyVShow"), `n${element}`, [
		`() => (`,
		...genExpression(oper.dir.exp, context),
		`)`
	]);
}
//#endregion
//#region packages/compiler-vapor/src/generators/directive.ts
function genBuiltinDirective(oper, context) {
	let call;
	switch (oper.name) {
		case "show":
			call = genVShow(oper, context);
			break;
		case "model":
			call = genVModel(oper, context);
			break;
		default: return [];
	}
	return [NEWLINE, ...oper.once ? genOnce(call, context) : call];
}
/**
* user directives via `withVaporDirectives`, emitted at the end of the block
* so the element's props, children and v-model are in place first
*/
function genCustomDirectives(operations, context) {
	const byElement = /* @__PURE__ */ new Map();
	for (const oper of operations) if (oper.type === 13 && !oper.builtin) {
		const dirs = byElement.get(oper.element);
		if (dirs) dirs.push(oper);
		else byElement.set(oper.element, [oper]);
	}
	const [frag, push] = buildCodeFragment();
	for (const dirs of byElement.values()) push(...genElementDirectives(dirs, context));
	return frag;
}
function genElementDirectives(opers, context) {
	const { helper } = context;
	const element = `n${opers[0].element}`;
	const directiveItems = opers.map(genDirectiveItem);
	const directives = genMulti(DELIMITERS_ARRAY, ...directiveItems);
	const call = genCall(helper("withVaporDirectives"), element, directives);
	return [NEWLINE, ...opers[0].once ? genOnce(call, context) : call];
	function genDirectiveItem({ dir, name, asset }) {
		const directiveVar = asset ? toValidAssetId(name, "directive") : genExpression(extend(createSimpleExpression(name, false), { ast: null }), context);
		const value = dir.exp && [
			"() => (",
			...genExpression(dir.exp, context),
			")"
		];
		const argument = dir.arg && [
			"() => (",
			...genExpression(dir.arg, context),
			")"
		];
		const modifiers = !!dir.modifiers.length && [
			"{ ",
			genDirectiveModifiers(dir.modifiers.map((m) => m.content)),
			" }"
		];
		return genMulti(DELIMITERS_ARRAY.concat("void 0"), directiveVar, value, argument, modifiers);
	}
}
//#endregion
//#region packages/compiler-vapor/src/generators/key.ts
function genKey(oper, context) {
	const { id, value, block, slotRoot } = oper;
	const [frag, push] = buildCodeFragment();
	const blockFn = genBlock(block, context);
	push(NEWLINE, `const n${id} = `, ...genCall(context.helper("createKeyedFragment"), [
		`() => (`,
		...genExpression(value, context),
		")"
	], blockFn, slotRoot ? "true" : false));
	return frag;
}
function genSetBlockKey(oper, context) {
	return [NEWLINE, ...genCall(context.helper("setBlockKey"), `n${oper.element}`, genExpression(oper.value, context))];
}
//#endregion
//#region packages/compiler-vapor/src/generators/operation.ts
function genOperations(opers, context) {
	const [frag, push] = buildCodeFragment();
	for (const operation of opers) push(...genOperationWithInsertionState(operation, context));
	return frag;
}
function genOperationWithInsertionState(oper, context) {
	const [frag, push] = buildCodeFragment();
	if (isBlockOperation(oper) && oper.parent) push(...genInsertionState(oper, context));
	push(...genOperation(oper, context));
	return frag;
}
function genOperation(oper, context) {
	switch (oper.type) {
		case 2: return genSetBlockKey(oper, context);
		case 3: return genSetProp(oper, context);
		case 4: return genDynamicProps$1(oper, context);
		case 5: return genSetText(oper, context);
		case 6: return genSetEvent(oper, context);
		case 7: return genSetDynamicEvents(oper, context);
		case 8: return genSetHtml(oper, context);
		case 9: return genSetTemplateRef(oper, context);
		case 10: return genInsertNode(oper, context);
		case 14: return genIf(oper, context);
		case 15: return genFor(oper, context);
		case 16: return genKey(oper, context);
		case 11: return genCreateComponent(oper, context);
		case 12: return genSlotOutlet(oper, context);
		case 13: return genBuiltinDirective(oper, context);
		case 17: return genGetTextChild(oper, context);
		default: throw new Error(`Unhandled operation type in genOperation: ${oper}`);
	}
}
function genEffects(effects, context, genExtraFrag) {
	const [frag, push] = buildCodeFragment();
	let start = 0;
	for (let i = 0; i < effects.length; i++) {
		const effect = effects[i];
		if (effect.once) {
			push(...genReactiveEffects(effects.slice(start, i), context));
			push(...genOperations(effect.operations, context));
			start = i + 1;
		}
	}
	push(...genReactiveEffects(effects.slice(start), context, genExtraFrag));
	return frag;
}
function genReactiveEffects(effects, context, genExtraFrag) {
	const { helper } = context;
	const expressions = effects.flatMap((effect) => effect.expressions);
	const [frag, push, unshift] = buildCodeFragment();
	const shouldDeclare = genExtraFrag === void 0;
	let operationsCount = 0;
	const { ids, frag: declarationFrags, varNames, expressionReplacements } = processExpressions(context, expressions, shouldDeclare);
	if (shouldDeclare && !declarationFrags.length && !varNames.length) {
		const effect = effects.length === 1 ? effects[0] : void 0;
		const operation = effect && effect.operations.length === 1 ? effect.operations[0] : void 0;
		if (operation && operation.type === 9 && operation.effect && !operation.refFor) return context.withExpressionReplacements(expressionReplacements, () => context.withId(() => genSetTemplateRefBinding(operation, context), ids));
	}
	return context.withExpressionReplacements(expressionReplacements, () => {
		push(...declarationFrags);
		for (let i = 0; i < effects.length; i++) {
			const effect = effects[i];
			operationsCount += effect.operations.length;
			const frags = context.withId(() => genEffect(effect, context), ids);
			i > 0 && push(NEWLINE);
			if (frag[frag.length - 1] === ")" && frags[0] === "(") push(";");
			push(...frags);
		}
		if (frag.filter((frag) => frag === NEWLINE).length > 1 || operationsCount > 1 || declarationFrags.length > 0) {
			unshift(`{`, INDENT_START, NEWLINE);
			push(INDENT_END, NEWLINE, "}");
			if (!effects.length) unshift(NEWLINE);
		}
		if (effects.length) {
			unshift(NEWLINE, `${helper("renderEffect")}(() => `);
			push(`)`);
		}
		if (!shouldDeclare && varNames.length) unshift(NEWLINE, `let `, varNames.join(", "));
		if (genExtraFrag) push(...context.withId(genExtraFrag, ids));
		return frag;
	});
}
function genEffect({ operations }, context) {
	const [frag, push] = buildCodeFragment();
	const operationsExps = genOperations(operations, context);
	if (operationsExps.filter((frag) => frag === NEWLINE).length > 1) push(...operationsExps);
	else push(...operationsExps.filter((frag) => frag !== NEWLINE));
	return frag;
}
function genInsertionState(operation, context) {
	const { parent, anchor, appendIndex } = operation;
	return [NEWLINE, ...genCall(context.helper("setInsertionState"), `n${parent}`, anchor != null ? `n${anchor}` : appendIndex ? String(appendIndex) : void 0)];
}
//#endregion
//#region packages/compiler-vapor/src/generators/template.ts
function genTemplates(templates, context) {
	const result = [];
	templates.forEach(({ content, ns, root, static: isStatic }, i) => {
		let args = JSON.stringify(content).replace(IMPORT_EXPR_RE, `" + $1 + "`);
		const flags = (root ? 1 : 0) | (isStatic ? 2 : 0);
		if (flags || ns) args += `, ${flags}`;
		if (ns) args += `, ${ns}`;
		result.push(`const ${context.tName(i)} = ${context.helper("template")}(${args})\n`);
	});
	return result.join("");
}
function genSelf(dynamic, context, flushBeforeDynamic) {
	const [frag, push] = buildCodeFragment();
	const { id, template, operation, hasDynamicChild } = dynamic;
	if (id !== void 0 && template !== void 0) {
		if (operation && operation.type === 10 && operation.appendIndex !== void 0) push(...genInsertionState(operation, context));
		push(NEWLINE, `const n${id} = ${context.tName(template)}()`);
	}
	if (operation) push(...genOperationWithInsertionState(operation, context));
	if (hasDynamicChild) push(...genChildren(dynamic, context, push, `n${id}`, flushBeforeDynamic));
	return frag;
}
function genChildren(dynamic, context, pushBlock, from = `n${dynamic.id}`, flushBeforeDynamic) {
	const [frag, push] = buildCodeFragment();
	const { children } = dynamic;
	let offset = 0;
	/**
	* `reusable` means the previous access target is a p* cursor that can be
	* reassigned by the next lookup. Referenced n* variables must stay stable.
	*/
	let prev;
	for (const [index, child] of children.entries()) {
		if (child.flags & 2) offset--;
		if (child.flags & 4 && child.template != null) {
			if (child.anchor !== void 0) {
				const elementIndex = index + offset;
				const variable = `n${child.anchor}`;
				pushBlock(NEWLINE, `const ${variable} = `, ...genAccessPath(context, from, elementIndex, prev));
				prev = [
					variable,
					elementIndex,
					false
				];
			}
			flushBeforeDynamic && flushBeforeDynamic(child, push);
			push(...genSelf(child, context, flushBeforeDynamic));
			continue;
		}
		const id = child.flags & 1 ? child.flags & 4 ? child.anchor : child.id : void 0;
		const ownsSubtree = child.operation !== void 0;
		if (id === void 0 && (!child.hasDynamicChild || ownsSubtree)) {
			flushBeforeDynamic && flushBeforeDynamic(child, push);
			push(...genSelf(child, context, flushBeforeDynamic));
			continue;
		}
		const elementIndex = index + offset;
		const inlinePlaceholder = id === void 0 && canInlinePlaceholder(child) && child.template == null && child.operation === void 0 && !(child.flags & 6);
		const accessPath = genAccessPath(context, from, elementIndex, prev, child.isText);
		if (inlinePlaceholder) {
			if (prev && prev[2]) {
				push(...genChildren(child, context, pushBlock, [
					"(",
					prev[0],
					" = ",
					...accessPath,
					")"
				], flushBeforeDynamic));
				prev = [
					prev[0],
					elementIndex,
					true
				];
				continue;
			}
			if (!hasAdjacentFollowingAccessChild(children, index, elementIndex, offset)) {
				push(...genChildren(child, context, pushBlock, accessPath, flushBeforeDynamic));
				continue;
			}
		}
		let variable;
		if (id === void 0 && prev && prev[2]) {
			variable = prev[0];
			pushBlock(NEWLINE, `${variable} = `, ...accessPath);
		} else {
			variable = id === void 0 ? context.pName(context.block.tempId++) : `n${id}`;
			pushBlock(NEWLINE, id === void 0 ? `let ${variable} = ` : `const ${variable} = `, ...accessPath);
		}
		if (id === child.anchor && (!child.hasDynamicChild || ownsSubtree)) {
			flushBeforeDynamic && flushBeforeDynamic(child, push);
			push(...genSelf(child, context, flushBeforeDynamic));
		}
		prev = [
			variable,
			elementIndex,
			id === void 0
		];
		if (!ownsSubtree) push(...genChildren(child, context, pushBlock, variable, flushBeforeDynamic));
	}
	return frag;
}
/**
* Build one DOM lookup path while preserving the fast sibling walk:
* adjacent nodes use _next(prev), otherwise fall back to _nthChild(parent).
*/
function genAccessPath({ helper }, from, elementIndex, prev, isText) {
	const textHint = isText ? "true" : void 0;
	if (prev) return elementIndex - prev[1] === 1 ? genCall(helper("next"), prev[0], textHint) : genCall(helper("nthChild"), from, String(elementIndex), textHint);
	if (elementIndex === 0) return genCall(helper("child"), from, textHint);
	if (elementIndex === 1) {
		const firstChild = genCall(helper("child"), from);
		return genCall(helper("next"), firstChild, textHint);
	}
	return genCall(helper("nthChild"), from, String(elementIndex), textHint);
}
/**
* Only inline a placeholder when materializing it would not save a parent
* lookup. If its child tree needs the parent more than once, keep p* so the
* generated code does not duplicate _child/_nthChild work.
*/
function canInlinePlaceholder(dynamic) {
	return dynamic.hasDynamicChild === true && countParentAccessUsages(dynamic) === 1;
}
/**
* A following access can reuse the current placeholder cursor only when it is
* the next DOM sibling. Gapped siblings need _nthChild(parent, index) instead.
* Kept in lockstep with genChildren's traversal rules.
*/
function hasAdjacentFollowingAccessChild(children, index, elementIndex, offset) {
	let futureOffset = offset;
	for (let i = index + 1; i < children.length; i++) {
		const child = children[i];
		if (child.flags & 2) futureOffset--;
		if (child.flags & 4 && child.anchor === void 0) continue;
		if (!!(child.flags & 1) || child.hasDynamicChild) return i + futureOffset - elementIndex === 1;
	}
	return false;
}
/**
* Mirrors genChildren's traversal closely enough to count how many emitted
* access paths would start from this placeholder's parent. This is the guard
* that keeps inline placeholders from duplicating parent lookups.
*/
function countParentAccessUsages(dynamic) {
	let usages = 0;
	let offset = 0;
	let prev;
	for (const [index, child] of dynamic.children.entries()) {
		if (child.flags & 2) offset--;
		if (child.flags & 4 && child.template != null && child.anchor === void 0) continue;
		const id = child.flags & 1 ? child.flags & 4 ? child.anchor : child.id : void 0;
		if (id === void 0 && !child.hasDynamicChild) continue;
		const elementIndex = index + offset;
		const usesParent = !prev || elementIndex - prev[0] !== 1;
		if (id === void 0 && canInlinePlaceholder(child) && child.template == null && child.operation === void 0 && !(child.flags & 6)) {
			if (prev && prev[1]) {
				if (usesParent) usages++;
				prev = [elementIndex, true];
				continue;
			}
			if (!hasAdjacentFollowingAccessChild(dynamic.children, index, elementIndex, offset)) {
				if (usesParent) usages++;
				continue;
			}
		}
		if (usesParent) usages++;
		prev = [elementIndex, id === void 0];
	}
	return usages;
}
//#endregion
//#region packages/compiler-vapor/src/generators/block.ts
function genBlock(oper, context, args = [], root) {
	return [
		"(",
		...args,
		") => {",
		INDENT_START,
		...genBlockContent(oper, context, root),
		INDENT_END,
		NEWLINE,
		"}"
	];
}
function genBlockContent(block, context, root, genEffectsExtraFrag, skippedEffectIndexes) {
	const [frag, push] = buildCodeFragment();
	const { dynamic, effect, operation, returns } = block;
	const modelOperations = operation.filter(isVModelOperation);
	const modelElements = new Set(modelOperations.map((oper) => oper.element));
	const isModelListener = (oper) => isVModelListener(oper, modelElements);
	const isDeferred = (oper) => isVModelOperation(oper) || isModelListener(oper);
	const modelListenerEffects = [];
	if (modelElements.size) {
		for (let i = 0; i < effect.length; i++) if (!(skippedEffectIndexes && skippedEffectIndexes.has(i)) && effect[i].operations.every(isModelListener)) modelListenerEffects.push(effect[i]);
	}
	const resetBlock = context.enterBlock(block);
	const singleUseAssetComponentNames = root ? collectSingleUseAssetComponents(block) : void 0;
	const prevSingleUseAssetComponentNames = context.singleUseAssetComponentNames;
	if (singleUseAssetComponentNames) context.singleUseAssetComponentNames = singleUseAssetComponentNames;
	if (root) {
		for (let name of context.ir.component) {
			if (singleUseAssetComponentNames && singleUseAssetComponentNames.has(name)) continue;
			const id = toValidAssetId(name, "component");
			const maybeSelfReference = name.endsWith("__self");
			if (maybeSelfReference) name = name.slice(0, -6);
			push(NEWLINE, `const ${id} = `, ...genCall(context.helper("resolveComponent"), JSON.stringify(name), maybeSelfReference ? "true" : void 0));
		}
		genResolveAssets("directive", "resolveDirective");
	}
	let operationIndex = 0;
	let effectIndex = 0;
	const flushPendingOperations = (operationEnd, effectEnd, push) => {
		while (operationIndex < operationEnd) {
			const oper = operation[operationIndex];
			if (!isDeferred(oper)) push(...genOperationWithInsertionState(oper, context));
			operationIndex++;
		}
		if (effectIndex < effectEnd) {
			push(...genEffectRange(effectIndex, effectEnd));
			effectIndex = effectEnd;
		}
	};
	const flushBeforeDynamic = (dynamic, push) => {
		const operation = dynamic.operation;
		if (operation && isBlockOperation(operation) && operation.operationIndex !== void 0 && operation.effectIndex !== void 0) flushPendingOperations(operation.operationIndex, operation.effectIndex, push);
	};
	for (const child of dynamic.children) {
		flushBeforeDynamic(child, push);
		push(...genSelf(child, context, flushBeforeDynamic));
	}
	for (const child of dynamic.children) if (!child.hasDynamicChild) push(...genChildren(child, context, push, `n${child.id}`, flushBeforeDynamic));
	if (operationIndex < operation.length) push(...genOperations(operation.slice(operationIndex).filter((oper) => !isDeferred(oper)), context));
	if (effectIndex < effect.length) push(...genEffectRange(effectIndex, effect.length, genEffectsExtraFrag));
	else if (genEffectsExtraFrag) push(...genEffects([], context, genEffectsExtraFrag));
	if (modelOperations.length) {
		push(...genOperations(modelOperations, context));
		push(...genOperations(operation.filter(isModelListener), context));
		if (modelListenerEffects.length) push(...genEffects(modelListenerEffects, context));
	}
	push(...genCustomDirectives(operation, context));
	push(NEWLINE, `return `);
	const returnNodes = returns.map((n) => `n${n}`);
	push(...returnNodes.length > 1 ? genMulti(DELIMITERS_ARRAY, ...returnNodes) : [returnNodes[0] || "[]"]);
	resetBlock();
	context.singleUseAssetComponentNames = prevSingleUseAssetComponentNames;
	return frag;
	function genEffectRange(start, end, genExtraFrag) {
		if (!skippedEffectIndexes && !modelListenerEffects.length) return genEffects(effect.slice(start, end), context, genExtraFrag);
		const effects = [];
		for (let i = start; i < end; i++) if (!(skippedEffectIndexes && skippedEffectIndexes.has(i)) && !modelListenerEffects.includes(effect[i])) effects.push(effect[i]);
		if (effects.length || genExtraFrag) return genEffects(effects, context, genExtraFrag);
		return [];
	}
	function genResolveAssets(kind, helper) {
		for (const name of context.ir[kind]) push(NEWLINE, `const ${toValidAssetId(name, kind)} = `, ...genCall(context.helper(helper), JSON.stringify(name)));
	}
}
function isVModelOperation(oper) {
	return oper.type === 13 && oper.builtin === true && oper.name === "model";
}
function isVModelListener(oper, modelElements) {
	return (oper.type === 6 || oper.type === 7 || oper.type === 4 && oper.listeners || oper.type === 3 && !oper.prop.modifier && isOn(oper.prop.key.content)) && modelElements.has(oper.element);
}
function markSlotRootOperations(block, context, sharedFallback = false) {
	if (hasStableSlotRoot(block, context)) return;
	sharedFallback = sharedFallback || hasMultipleDynamicSlotRoots(block);
	for (let i = 0; i < block.returns.length; i++) {
		const child = findReturnedDynamic$1(block, block.returns[i]);
		const operation = child && child.operation;
		if (!operation) continue;
		if (operation.type === 14) markSlotRootIf(operation, context, sharedFallback);
		else if (operation.type === 15) markSlotRootFor(operation, context);
		else if (operation.type === 16) {
			operation.slotRoot = true;
			markSlotRootOperations(operation.block, context, sharedFallback);
		} else if (operation.type === 11) markSlotRootComponent(operation);
		else if (operation.type === 12) {
			operation.flags |= 4;
			if (sharedFallback) operation.flags |= 8;
		}
	}
}
function markSlotRootIf(operation, context, sharedFallback) {
	if (!operation.once) operation.slotRoot = true;
	markSlotRootOperations(operation.positive, context, sharedFallback);
	const negative = operation.negative;
	if (!negative) return;
	if (negative.type === 14) markSlotRootIf(negative, context, sharedFallback);
	else markSlotRootOperations(negative, context, sharedFallback);
}
function markSlotRootFor(operation, context) {
	if (!operation.once) operation.slotRoot = true;
	markSlotRootOperations(operation.render, context, true);
}
function hasMultipleDynamicSlotRoots(block) {
	let count = 0;
	for (let i = 0; i < block.returns.length; i++) {
		const child = findReturnedDynamic$1(block, block.returns[i]);
		if (child && child.operation && ++count > 1) return true;
	}
	return false;
}
function markSlotRootComponent(operation) {
	if (!operation.once && operation.dynamic && !operation.dynamic.isStatic) operation.slotRoot = true;
}
function findReturnedDynamic$1(block, id) {
	for (let i = 0; i < block.dynamic.children.length; i++) {
		const child = block.dynamic.children[i];
		if (child.id === id) return child;
	}
}
const commentOnlyTemplateRE = /^(?:<!--[\s\S]*?-->)+$/;
function hasStableSlotRoot(block, context) {
	let hasValidRoot = false;
	for (let i = 0; i < block.returns.length; i++) {
		const id = block.returns[i];
		const child = findReturnedDynamic$1(block, id);
		const operation = child && child.operation;
		if (!operation) {
			if (child && isStableTemplateSlotRoot(child, context)) hasValidRoot = true;
			continue;
		}
		switch (operation.type) {
			case 11:
				if (!operation.dynamic || operation.dynamic.isStatic) {
					hasValidRoot = true;
					continue;
				}
				continue;
			case 16:
				if (hasStableSlotRoot(operation.block, context)) {
					hasValidRoot = true;
					continue;
				}
				continue;
			default: continue;
		}
	}
	return hasValidRoot;
}
function isStableTemplateSlotRoot(child, context) {
	if (child.template == null) return false;
	const content = context.ir.template.entries[child.template].content;
	return content !== "" && !commentOnlyTemplateRE.test(content.trim());
}
function collectSingleUseAssetComponents(block) {
	const usageMap = /* @__PURE__ */ new Map();
	const seenOperations = /* @__PURE__ */ new Set();
	visitBlock(block, true);
	const names = /* @__PURE__ */ new Set();
	for (const [name, usage] of usageMap) if (usage.count === 1 && usage.root) names.add(name);
	return names;
	function visitBlock(block, rootCandidate) {
		visitDynamic(block.dynamic, rootCandidate);
		for (const operation of block.operation) visitOperation(operation, rootCandidate);
		for (const effect of block.effect) for (const operation of effect.operations) visitOperation(operation, false);
	}
	function visitDynamic(dynamic, rootCandidate) {
		if (dynamic.operation) visitOperation(dynamic.operation, rootCandidate);
		for (const child of dynamic.children) visitDynamic(child, rootCandidate);
	}
	function visitOperation(operation, rootCandidate) {
		if (seenOperations.has(operation)) return;
		seenOperations.add(operation);
		if (operation.type === 11) {
			if (operation.asset) {
				const usage = usageMap.get(operation.tag) || {
					count: 0,
					root: false
				};
				usage.count++;
				if (rootCandidate) usage.root = true;
				usageMap.set(operation.tag, usage);
			}
			visitSlots(operation.slots);
			return;
		}
		switch (operation.type) {
			case 14:
				visitBlock(operation.positive, false);
				if (operation.negative) {
					if (operation.negative.type === 14) visitOperation(operation.negative, false);
					else visitBlock(operation.negative, false);
				}
				break;
			case 15:
				visitBlock(operation.render, false);
				break;
			case 16:
				visitBlock(operation.block, false);
				break;
			case 12: if (operation.fallback) visitBlock(operation.fallback, false);
		}
	}
	function visitSlots(slots) {
		for (const slot of slots) switch (slot.slotType) {
			case 0:
				for (const name in slot.slots) visitBlock(slot.slots[name], false);
				break;
			case 1:
			case 2:
				visitBlock(slot.fn, false);
				break;
			case 3:
				visitSlots([slot.positive]);
				if (slot.negative) visitSlots([slot.negative]);
		}
	}
}
//#endregion
//#region packages/compiler-vapor/src/generate.ts
const idWithTrailingDigitsRE = /^([A-Za-z_$][\w$]*)(\d+)$/;
const helperNameAliases = {
	withVaporKeys: "withKeys",
	withVaporModifiers: "withModifiers"
};
var CodegenContext = class {
	withExpressionReplacements(map, fn) {
		if (map.size === 0) return fn();
		this.expressionReplacements.unshift(map);
		try {
			return fn();
		} finally {
			remove(this.expressionReplacements, map);
		}
	}
	getExpressionReplacement(node) {
		for (const map of this.expressionReplacements) {
			const replacement = map.get(node);
			if (replacement) return replacement;
		}
		return node;
	}
	withId(fn, map) {
		const { identifiers } = this;
		const ids = Object.keys(map);
		for (const id of ids) {
			identifiers[id] || (identifiers[id] = []);
			identifiers[id].unshift(map[id] || id);
		}
		const ret = fn();
		ids.forEach((id) => remove(identifiers[id], map[id] || id));
		return ret;
	}
	enterBlock(block) {
		const parent = this.block;
		this.block = block;
		return () => this.block = parent;
	}
	enterSlotBlock() {
		const parent = this.inSlotBlock;
		this.inSlotBlock = true;
		return () => this.inSlotBlock = parent;
	}
	enterScope() {
		return [this.scopeLevel++, () => this.scopeLevel--];
	}
	getUniqueLocalName(base, scopeNames = this.generatedLocalNames) {
		const name = this.findAvailableName(base, scopeNames);
		scopeNames.add(name);
		this.generatedLocalNames.add(name);
		return name;
	}
	isNameAvailable(name, reservedNames) {
		var _this$identifiers$nam;
		if (this.bindingNames.has(name) || reservedNames.has(name)) return false;
		if ((_this$identifiers$nam = this.identifiers[name]) === null || _this$identifiers$nam === void 0 ? void 0 : _this$identifiers$nam.length) return false;
		for (const alias of this.helpers.values()) if (alias === name) return false;
		return true;
	}
	findAvailableName(base, reservedNames) {
		if (this.isNameAvailable(base, reservedNames)) return base;
		const map = this.nextIdMap.get(base);
		let next = 1;
		while (true) {
			const id = getNextId(map, next);
			const name = `${base}${id}`;
			if (this.isNameAvailable(name, reservedNames)) return name;
			next = id + 1;
		}
	}
	initNextIdMap() {
		if (this.bindingNames.size === 0) return;
		const map = /* @__PURE__ */ new Map();
		for (const name of this.bindingNames) {
			const m = idWithTrailingDigitsRE.exec(name);
			if (!m) continue;
			const prefix = m[1];
			const num = Number(m[2]);
			let set = map.get(prefix);
			if (!set) map.set(prefix, set = /* @__PURE__ */ new Set());
			set.add(num);
		}
		for (const [prefix, nums] of map) this.nextIdMap.set(prefix, buildNextIdMap(nums));
	}
	tName(i) {
		let name = this.templateVars.get(i);
		if (name) return name;
		const map = this.nextIdMap.get("t");
		let lastId = this.lastIdMap.get("t") || -1;
		for (let j = this.lastTIndex + 1; j <= i; j++) this.templateVars.set(j, name = `t${lastId = getNextId(map, Math.max(j, lastId + 1))}`);
		this.lastIdMap.set("t", lastId);
		this.lastTIndex = i;
		return name;
	}
	pName(i) {
		return this.idName("p", i);
	}
	kName(i) {
		return this.idName("k", i);
	}
	idName(prefix, i) {
		const map = this.nextIdMap.get(prefix);
		let lastId = this.lastIdMap.get(prefix) || -1;
		this.lastIdMap.set(prefix, lastId = getNextId(map, Math.max(i, lastId + 1)));
		return `${prefix}${lastId}`;
	}
	constructor(ir, options) {
		this.ir = ir;
		this.bindingNames = /* @__PURE__ */ new Set();
		this.helpers = /* @__PURE__ */ new Map();
		this.needsTemplateRefSetter = false;
		this.inSlotBlock = false;
		this.helper = (name) => {
			if (this.helpers.has(name)) return this.helpers.get(name);
			const base = `_${helperNameAliases[name] || name}`;
			const alias = this.findAvailableName(base, this.generatedLocalNames);
			this.helpers.set(name, alias);
			return alias;
		};
		this.delegates = /* @__PURE__ */ new Set();
		this.dynamicPropNames = /* @__PURE__ */ new Map();
		this.identifiers = Object.create(null);
		this.expressionReplacements = [];
		this.seenInlineHandlerNames = Object.create(null);
		this.scopeLevel = 0;
		this.templateVars = /* @__PURE__ */ new Map();
		this.nextIdMap = /* @__PURE__ */ new Map();
		this.lastIdMap = /* @__PURE__ */ new Map();
		this.generatedLocalNames = /* @__PURE__ */ new Set();
		this.lastTIndex = -1;
		const defaultOptions = {
			mode: "module",
			prefixIdentifiers: true,
			sourceMap: false,
			filename: `template.vue.html`,
			scopeId: null,
			runtimeGlobalName: `Vue`,
			runtimeModuleName: `vue`,
			ssrRuntimeModuleName: "vue/server-renderer",
			ssr: false,
			isTS: false,
			inSSR: false,
			inline: false,
			bindingMetadata: {},
			expressionPlugins: []
		};
		this.options = extend(defaultOptions, options);
		this.block = ir.block;
		this.bindingNames = new Set(this.options.bindingMetadata ? Object.keys(this.options.bindingMetadata) : []);
		this.initNextIdMap();
	}
};
function generate(ir, options = {}) {
	const [frag, push] = buildCodeFragment();
	const context = new CodegenContext(ir, options);
	const { inline, bindingMetadata } = options;
	const functionName = "render";
	const args = ["_ctx"];
	if (bindingMetadata && !inline) args.push("$props", "$emit", "$attrs", "$slots");
	const signature = (options.isTS ? args.map((arg) => `${arg}: any`) : args).join(", ");
	if (!inline) push(NEWLINE, `export function ${functionName}(${signature}) {`);
	push(INDENT_START);
	const templateRefSetterHelper = ir.hasTemplateRef ? context.helper("createTemplateRefSetter") : void 0;
	const body = genBlockContent(ir.block, context, true);
	if (context.needsTemplateRefSetter) push(NEWLINE, `const ${setTemplateRefIdent} = ${templateRefSetterHelper}()`);
	else if (templateRefSetterHelper) context.helpers.delete("createTemplateRefSetter");
	push(...body);
	push(INDENT_END, NEWLINE);
	if (!inline) push("}");
	const delegates = genDelegates(context);
	const templates = genTemplates(ir.template.entries, context);
	const preamble = genHelperImports(context) + genAssetImports(context) + templates + genDynamicPropNames(context) + delegates;
	const newlineCount = [...preamble].filter((c) => c === "\n").length;
	if (newlineCount && !inline) frag.unshift(...new Array(newlineCount).fill(LF));
	let [code, map] = codeFragmentToString(frag, context);
	if (!inline) code = preamble + code;
	return {
		code,
		ast: ir,
		preamble,
		map: map && map.toJSON(),
		helpers: new Set(Array.from(context.helpers.keys()))
	};
}
function genDynamicPropNames({ dynamicPropNames }) {
	let code = "";
	for (const [json, id] of dynamicPropNames) code += `const ${id} = ${json}\n`;
	return code;
}
function genDelegates({ delegates, helper }) {
	return delegates.size ? genCall(helper("delegateEvents"), ...Array.from(delegates).map((v) => `"${v}"`)).join("") + "\n" : "";
}
function genHelperImports({ helpers, options }) {
	let imports = "";
	if (helpers.size) imports += `import { ${Array.from(helpers).map(([h, alias]) => `${h} as ${alias}`).join(", ")} } from '${options.runtimeModuleName}';\n`;
	return imports;
}
function genAssetImports({ ir }) {
	const assetImports = ir.node.imports;
	let imports = "";
	for (const assetImport of assetImports) {
		const name = assetImport.exp.content;
		imports += `import ${name} from '${assetImport.path}';\n`;
	}
	return imports;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vBind.ts
function normalizeBindShorthand(arg, context) {
	if (arg.type !== 4 || !arg.isStatic) {
		context.options.onError(createCompilerError(53, arg.loc));
		return createSimpleExpression("", true, arg.loc);
	}
	const exp = createSimpleExpression(camelize(arg.content), false, arg.loc);
	exp.ast = null;
	return exp;
}
const transformVBind = (dir, node, context) => {
	const { loc, modifiers } = dir;
	let { exp } = dir;
	let arg = dir.arg;
	const modifiersString = modifiers.map((s) => s.content);
	if (!exp) exp = normalizeBindShorthand(arg, context);
	if (!exp.content.trim()) {
		context.options.onError(createCompilerError(34, loc));
		exp = createSimpleExpression("", true, loc);
	}
	arg = resolveExpression(arg);
	const excludeNumber = node.tagType === 1 || node.tagType === 2 || !!context.options.isCustomElement(node.tag) || modifiersString.includes("prop") || !arg.isStatic || isSpecialBooleanAttr(arg.content) || isCheckboxValueProp(node, arg.content) || !modifiersString.includes("attr") && (isFoldableBooleanAttr(arg.content) || isModelValueProp(node, arg.content));
	exp = resolveExpression(exp, excludeNumber);
	if (arg.isStatic && isReservedProp(arg.content)) return;
	let camel = false;
	if (modifiersString.includes("camel")) {
		if (arg.isStatic) arg = extend({}, arg, { content: camelize(arg.content) });
		else camel = true;
	}
	return {
		key: arg,
		value: exp,
		loc,
		runtimeCamelize: camel,
		modifier: modifiersString.includes("prop") ? "." : modifiersString.includes("attr") ? "^" : void 0
	};
};
//#endregion
//#region packages/compiler-vapor/src/transforms/transformKey.ts
init_objectSpread2();
const dynamicComponentKeys = /* @__PURE__ */ new WeakMap();
const transformKey = (node, context) => {
	if (node.type !== 1 || context.inVOnce || findDir(node, "for") || node.tagType === 3 && findDir(node, /^(if|else-if|else|slot)$/, true)) return;
	if (isComponentTag(node.tag) && findProp(node, "is", true, true)) {
		const prop = findProp(node, "key", false, true);
		if (prop) dynamicComponentKeys.set(node, prop.type === 6 ? createSimpleExpression(prop.value ? prop.value.content : "", true) : prop.exp || normalizeBindShorthand(prop.arg, context));
		return;
	}
	const dir = findProp(node, "key", true, true);
	if (!dir || dir.type === 6) return;
	let value;
	value = dir.exp || normalizeBindShorthand(dir.arg, context);
	if (isStaticExpression(value, context.options.bindingMetadata)) return;
	let id = context.reference();
	context.dynamic.flags |= 6;
	context.node = node = wrapTemplate(node, ["key"]);
	const block = newBlock(node);
	const exitBlock = context.enterBlock(block);
	return () => {
		exitBlock();
		context.dynamic.operation = _objectSpread2(_objectSpread2({
			type: 16,
			id
		}, context.effectBoundary()), {}, {
			value,
			block
		});
	};
};
//#endregion
//#region packages/compiler-vapor/src/transforms/vHtml.ts
function ignoreVHtmlChildren(node, context, clear) {
	if (!node.children.length) return;
	const dir = findDir$1(node, "html");
	if (!dir) return;
	context.options.onError(createDOMCompilerError(55, dir.loc));
	if (clear === "node") node.children.length = 0;
	else context.childrenTemplate.length = 0;
}
const transformVHtml = (dir, node, context) => {
	let { exp, loc } = dir;
	if (!exp) {
		context.options.onError(createDOMCompilerError(54, loc));
		exp = EMPTY_EXPRESSION;
	}
	ignoreVHtmlChildren(node, context, "template");
	if (node.tagType === 1) return {
		key: createSimpleExpression("innerHTML", true, loc),
		value: exp
	};
	context.registerEffect([exp], {
		type: 8,
		element: context.reference(),
		value: exp
	});
};
//#endregion
//#region packages/compiler-vapor/src/transforms/transformElement.ts
init_objectSpread2();
const isReservedProp = /*#__PURE__*/ makeMap(",key,ref,ref_for,ref_key,");
/**
* `true-value` / `false-value` are only read back by `v-model` on a checkbox,
* and they are dropped from the ssr output, so a checkbox that only carries
* them in the template has nothing left to read from after hydration. A
* dynamic `type` can still make the element a checkbox at runtime.
*/
function isCheckboxValueProp(node, key) {
	if (node.tag !== "input" || key !== "true-value" && key !== "false-value") return false;
	const type = findProp(node, "type");
	return type ? type.type === 7 || type.value.content === "checkbox" : hasDynamicKeyVBind(node);
}
/**
* Props the template string cannot carry, so they have to be applied by a
* runtime prop setter instead:
* - `innerHTML` / `textContent` are dom properties that set the element's
*   content; as a content attribute they would only sit on the element and
*   the content would never be written, so vdom always sets them as a dom
*   property too, see `shouldSetAsProp`
* - `<textarea>` / `<select>` ignore a `value` content attribute, the value
*   only takes effect as a dom property - which is where vdom sends it too,
*   see `shouldSetAsProp`
* - `true-value` / `false-value`, see `isCheckboxValueProp`
*/
function isRuntimeOnlyProp(node, key) {
	return key === "innerHTML" || key === "textContent" || key === "value" && (node.tag === "textarea" || node.tag === "select") || isCheckboxValueProp(node, key);
}
/**
* Props `v-model` reads back off the element as raw values (`_value`,
* `_trueValue`, `_falseValue`), so a number literal bound to them has to keep
* its type - vdom bails on `<option :value="1">` in its own static
* stringification for the same reason.
*
* Deliberately wider than `isRuntimeOnlyProp`: a literal `<input value="1">`
* belongs in the template string, only the type of a *bound* number has to
* survive. So this one is consulted by `v-bind`, that one by
* `transformNativeElement`.
*/
function isModelValueProp(node, key) {
	const { tag } = node;
	return key === "value" && (tag === "input" || tag === "option" || tag === "textarea" || tag === "select") || isCheckboxValueProp(node, key);
}
/**
* Boolean attributes are folded into the template from the value itself, which
* needs the type it was written with: `:disabled="0"` is `false`, while the
* `"0"` a stringified template attribute would carry is `true`. `hidden` is
* not a boolean attribute - it also takes `until-found` - but a number means
* the same thing there.
*/
function isFoldableBooleanAttr(key) {
	return isBooleanAttr(key) || key === "hidden";
}
const transformElement = (node, context) => {
	let effectIndex = context.block.effect.length;
	const getEffectIndex = () => effectIndex++;
	if (node.type === 1 && node.children.length) ignoreVHtmlChildren(node, context, "node");
	let parentSlots;
	if (node.type === 1 && (node.tagType === 1 || context.options.isCustomElement(node.tag))) {
		parentSlots = context.slots;
		context.slots = [];
	}
	return function postTransformElement() {
		({node} = context);
		if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) return;
		const useCreateElement = shouldUseCreateElement(node, context);
		const isComponent = node.tagType === 1 || useCreateElement;
		const isDynamicComponent = isComponentTag(node.tag);
		const staticKey = dynamicComponentKeys.has(node) ? void 0 : resolveStaticKey(node, context, isComponent);
		const propsResult = buildProps(node, context, isComponent, isDynamicComponent, getEffectIndex);
		const singleRoot = context.isSingleRoot;
		if (isComponent) transformComponentElement(node, propsResult, staticKey, singleRoot, context, isDynamicComponent, useCreateElement);
		else transformNativeElement(node, propsResult, staticKey, singleRoot, context, getEffectIndex, context.root === context.effectiveParent || canOmitEndTag(node, context));
		if (parentSlots) context.slots = parentSlots;
	};
};
function canOmitEndTag(node, context) {
	const { block, parent } = context;
	if (!parent) return false;
	if (block !== parent.block) return true;
	if (context.templateCloseTags && (context.templateCloseTags.has(node.tag) || context.templateCloseTags.has("form") || context.templateCloseTags.has("li") && (node.tag === "ul" || node.tag === "ol") || isAlwaysCloseTag(node.tag) || isFormattingTag(node.tag)) || context.templateCloseBlocks && isBlockTag(node.tag)) return false;
	if (isAlwaysCloseTag(node.tag) && !context.isOnRightmostPath) return false;
	if (isFormattingTag(node.tag) || parent.node.type === 1 && (node.tag === parent.node.tag || parent.node.ns !== 0 && node.ns !== parent.node.ns)) return context.isOnRightmostPath;
	return context.isLastEffectiveChild;
}
function getChildTemplateCloseState(context) {
	const { node } = context;
	if (node.type !== 1 || node.tagType !== 0 || shouldUseCreateElement(node, context)) return;
	const inSameTemplateAsParent = isInSameTemplateAsParent(context);
	const inheritedTags = inSameTemplateAsParent ? context.templateCloseTags : void 0;
	const inheritedBlocks = inSameTemplateAsParent && context.templateCloseBlocks;
	if (context.root === context.effectiveParent || canOmitEndTag(node, context) || isVoidTag(node.tag)) return inheritedTags || inheritedBlocks ? {
		tags: inheritedTags,
		blocks: inheritedBlocks
	} : void 0;
	const tags = new Set(inheritedTags);
	tags.add(node.tag);
	return {
		tags,
		blocks: inheritedBlocks || isInlineTag(node.tag)
	};
}
function isInSameTemplateAsParent(context) {
	const { parent, node, block } = context;
	if (!parent || block !== parent.block) return false;
	const parentNode = parent.node;
	if (parentNode.type !== 1 || parentNode.tagType !== 0) return false;
	return !shouldUseCreateElement(parentNode, parent) && isValidHTMLNesting(parentNode.tag, node.tag);
}
function transformComponentElement(node, propsResult, staticKey, singleRoot, context, isDynamicComponent, useCreateElement) {
	const dynamicComponent = isDynamicComponent ? resolveDynamicComponent(node) : void 0;
	let { tag } = node;
	let asset = true;
	if (!dynamicComponent && !useCreateElement) {
		const isProp = findProp(node, "is");
		if (isProp && isProp.type === 6 && isVueIsValue(isProp)) tag = isProp.value.content.slice(4);
		const fromSetup = resolveSetupReference(tag, context);
		if (fromSetup) {
			tag = fromSetup;
			asset = false;
		}
		const builtInTag = isBuiltInComponent(tag);
		if (builtInTag) {
			tag = builtInTag;
			asset = false;
		}
		const dotIndex = tag.indexOf(".");
		if (dotIndex > 0) {
			const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
			if (ns) {
				tag = ns + tag.slice(dotIndex);
				asset = false;
			}
		}
		if (asset) {
			if (context.selfName && capitalize(camelize(tag)) === context.selfName) tag += `__self`;
			context.component.add(tag);
		}
	}
	const props = propsResult[0] ? propsResult[1] : [propsResult[1]];
	if (staticKey && !useCreateElement) {
		const keyProp = {
			key: createSimpleExpression("key", true),
			values: [staticKey]
		};
		if (isArray$3(props[0])) props[0].push(keyProp);
		else props.unshift([keyProp]);
	}
	context.dynamic.flags |= 6;
	const id = context.reference();
	context.dynamic.operation = _objectSpread2(_objectSpread2({
		type: 11,
		id
	}, context.effectBoundary()), {}, {
		tag,
		props,
		asset,
		root: singleRoot,
		slots: [...context.slots],
		once: context.inVOnce,
		dynamic: dynamicComponent,
		useCreateElement,
		ns: node.ns || void 0,
		key: dynamicComponentKeys.get(node)
	});
	if (staticKey && (useCreateElement || dynamicComponent)) context.registerOperation(createSetBlockKey(id, staticKey));
	context.slots = [];
}
function isVueIsValue(prop) {
	return !!prop.value && prop.value.content.startsWith("vue:");
}
function resolveDynamicComponent(node) {
	const isProp = findProp(node, "is", false, true);
	if (!isProp) return;
	if (isProp.type === 6) return isProp.value && createSimpleExpression(isProp.value.content, true);
	else return isProp.exp || extend(createSimpleExpression(`is`, false, isProp.arg.loc), { ast: null });
}
function resolveSetupReference(name, context) {
	const bindings = context.options.bindingMetadata;
	if (!bindings || bindings.__isScriptSetup === false) return;
	const camelName = camelize(name);
	const PascalName = capitalize(camelName);
	return bindings[name] ? name : bindings[camelName] ? camelName : bindings[PascalName] ? PascalName : void 0;
}
const dynamicKeys = [
	"indeterminate",
	"volume",
	"playbackRate",
	"defaultPlaybackRate",
	"currentTime",
	"valueAsNumber"
];
const NEEDS_QUOTES_RE = /[\s"'`=<>]/;
const LEADING_NEWLINE_RE = /^\r?\n/;
const UNSAFE_ATTR_NAME_RE = /[\u0000-\u0020"'<=/>]/;
function transformNativeElement(node, propsResult, staticKey, singleRoot, context, getEffectIndex, omitEndTag) {
	const { tag } = node;
	const { scopeId } = context.options;
	const isSVG = node.ns === 1;
	let template = "";
	template += `<${tag}`;
	if (scopeId) template += ` ${scopeId}`;
	if (propsResult[0]) {
		const [, dynamicArgs, expressions] = propsResult;
		context.registerEffect(expressions, {
			type: 4,
			element: context.reference(),
			props: dynamicArgs,
			isSVG
		}, getEffectIndex);
	} else {
		const appendTemplateProp = (key, value = "") => {
			template += ` ${key}`;
			if (value) {
				const escapedValue = escapeAttrValue(value);
				template += NEEDS_QUOTES_RE.test(value) ? `="${escapedValue}"` : `=${escapedValue}`;
			}
		};
		const needsOrderedProps = tag === "input" && propsResult[1].some(({ key, modifier }) => key.content === "valueAsNumber" && modifier !== "^");
		const nativeOnProps = [];
		let hasEffect = false;
		for (const prop of propsResult[1]) {
			const { key, values } = prop;
			const canStringifyAttrName = key.isStatic && !UNSAFE_ATTR_NAME_RE.test(key.content);
			let foldedValue;
			if (!prop.modifier && isOn(key.content)) {
				if (!isModelListener(key.content)) {
					const operation = {
						type: 3,
						element: context.reference(),
						prop,
						tag,
						isSVG
					};
					hasEffect = context.registerEffect(values, operation, getEffectIndex, needsOrderedProps && hasEffect);
					operation.effect = hasEffect;
				}
			} else if (canStringifyAttrName && context.imports.some((imported) => values[0].content.includes(imported.exp.content))) template += ` ${key.content}="${IMPORT_EXP_START}${values[0].content}${IMPORT_EXP_END}"`;
			else if (canStringifyAttrName && prop.modifier !== "." && values.length === 1 && (values[0].isStatic || values[0].content === "''") && !dynamicKeys.includes(key.content) && !isRuntimeOnlyProp(node, key.content)) {
				const value = values[0].content === "''" ? "" : values[0].content;
				appendTemplateProp(key.content, value);
			} else if (canStringifyAttrName && !prop.modifier && isFoldableBooleanAttr(key.content) && (foldedValue = foldBooleanAttrValue(key.content, values)) != null) {
				if (foldedValue) appendTemplateProp(key.content);
			} else if (canStringifyAttrName && !prop.modifier && hasBoundValue(values) && (foldedValue = key.content === "class" ? foldClassValues(values) : key.content === "style" ? foldStyleValues(values) : void 0) != null) {
				if (foldedValue) appendTemplateProp(key.content, foldedValue);
			} else if (isSVG && !prop.modifier && isNativeOn(key.content)) nativeOnProps.push(prop);
			else hasEffect = context.registerEffect(values, {
				type: 3,
				element: context.reference(),
				prop,
				tag,
				isSVG
			}, getEffectIndex, needsOrderedProps && hasEffect);
		}
		if (nativeOnProps.length) context.registerEffect(nativeOnProps.flatMap(({ values }) => values), {
			type: 4,
			element: context.reference(),
			props: [nativeOnProps],
			isSVG
		}, getEffectIndex);
	}
	let children = context.childrenTemplate.join("");
	if (node.ns === 0 && parserOptions.isIgnoreNewlineTag(tag) && LEADING_NEWLINE_RE.test(children)) children = `\n` + children;
	template += `>` + children;
	if (!isVoidTag(tag) && !omitEndTag) template += `</${tag}>`;
	context.templateRoot = singleRoot;
	if (context.parent && context.parent.node.type === 1 && !isValidHTMLNesting(context.parent.node.tag, tag)) {
		context.reference();
		context.dynamic.template = context.pushTemplate(template);
		context.dynamic.flags |= 6;
	} else context.template += template;
	if (staticKey) context.registerOperation(createSetBlockKey(context.reference(), staticKey));
}
/**
* Templates are parsed as html again at runtime, so a value written into one
* has to survive that round trip unchanged. The parser has already decoded the
* character references in a static value, and `&` would start a second round
* of decoding, turning `&amp;lt;` into `<` instead of `&lt;`. This is the same
* reason the vdom static stringifier escapes values before putting them into
* an html string (`escapeHtml` in `stringifyStatic`).
*
* Character references are all this fixes. `<`, `>`, `'` and whitespace need no
* escaping because `NEEDS_QUOTES_RE` already puts every value containing them
* inside double quotes, where they stand for themselves. A CR or a NUL in the
* value does still come out differently than in vdom, but that is a class of
* its own: the parser normalizes both away while preprocessing its input, and
* it does so for comment data and for text in `<pre>` and `<textarea>` just the
* same, where a NUL cannot be written back at all.
*/
function escapeAttrValue(value) {
	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
}
function foldBooleanAttrValue(key, values) {
	if (values.length !== 1) return;
	const evaluated = evaluateConstantExpression(values[0]);
	if (!evaluated) return;
	const value = evaluated.value;
	if (key === "hidden" && typeof value === "number") return includeBooleanAttr(value);
	if (value === true || value === false || value == null) return includeBooleanAttr(value);
}
function foldStyleValues(values) {
	const evaluatedValues = [];
	for (const value of values) {
		const evaluated = evaluateConstantExpression(value);
		if (!evaluated || !isStaticStyleValue(evaluated.value)) return;
		evaluatedValues.push(evaluated.value);
	}
	return stringifyStyle(normalizeStyle(evaluatedValues.length === 1 ? evaluatedValues[0] : evaluatedValues));
}
function isStaticStyleValue(value) {
	if (typeof value === "string") return true;
	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
	for (const key in value) {
		const propValue = value[key];
		if (!isSafeStylePropertyName(key) || !isSafeStylePropertyValue(propValue)) return false;
	}
	return true;
}
function isSafeStylePropertyName(key) {
	return !!key && !/[;:]/.test(key);
}
function isSafeStylePropertyValue(value) {
	return typeof value === "number" || typeof value === "string" && !value.includes(";");
}
function hasBoundValue(values) {
	return values.some((value) => !value.isStatic && value.content !== "''");
}
function foldClassValues(values) {
	let templateValue = "";
	let changed = false;
	for (const value of values) {
		const evaluated = evaluateConstantExpression(value);
		if (evaluated) {
			const normalized = normalizeClass(evaluated.value);
			if (normalized) templateValue = appendClass(templateValue, normalized);
			else changed = true;
			continue;
		}
		return;
	}
	return changed || templateValue ? templateValue : void 0;
}
function appendClass(base, value) {
	return base ? value ? `${base} ${value}` : base : value;
}
function getObjectPropertyName(prop) {
	const key = prop.key;
	if (key.type === "Identifier") return key.name;
	else if (key.type === "StringLiteral") return key.value;
	else if (key.type === "NumericLiteral") return String(key.value);
}
function evaluateConstantExpression(node) {
	if (node.isStatic) return { value: node.content };
	const ast = node.ast;
	if (ast === null) {
		if (node.content === "true") return { value: true };
		else if (node.content === "false") return { value: false };
		else if (node.content === "null") return { value: null };
		else if (node.content === "undefined") return { value: void 0 };
	}
	if (!ast) return;
	return evaluateConstantAst(ast);
}
function evaluateConstantAst(node) {
	switch (node.type) {
		case "StringLiteral": return { value: node.value };
		case "NumericLiteral": return { value: node.value };
		case "BooleanLiteral": return { value: node.value };
		case "NullLiteral": return { value: null };
		case "Identifier": return node.name === "undefined" ? { value: void 0 } : void 0;
		case "UnaryExpression":
			if (node.operator === "void") return { value: void 0 };
			else if (node.operator === "-") {
				const value = evaluateConstantAst(node.argument);
				return value && typeof value.value === "number" ? { value: -value.value } : void 0;
			}
			return;
		case "TemplateLiteral": return evaluateTemplateLiteral(node);
		case "ObjectExpression": return evaluateObjectExpression(node);
	}
}
function evaluateTemplateLiteral(node) {
	if (node.type !== "TemplateLiteral") return;
	let value = "";
	for (const [index, quasi] of node.quasis.entries()) {
		value += quasi.value.cooked || "";
		const expression = node.expressions[index];
		if (expression) {
			const evaluated = evaluateConstantAst(expression);
			if (!evaluated) return;
			value += evaluated.value;
		}
	}
	return { value };
}
function evaluateObjectExpression(node) {
	const value = {};
	for (const prop of node.properties) {
		if (prop.type !== "ObjectProperty" || prop.computed) return;
		const key = getObjectPropertyName(prop);
		if (key == null) return;
		const evaluated = evaluateConstantAst(prop.value);
		if (!evaluated) return;
		value[key] = evaluated.value;
	}
	return { value };
}
function resolveStaticKey(node, context, isComponent) {
	if (context.parent.node !== context.block.node) return;
	const keyProp = findProp(node, "key", false, true);
	if (!keyProp) return;
	if (keyProp.type === 6) return keyProp.value ? createSimpleExpression(keyProp.value.content, true, keyProp.value.loc) : EMPTY_EXPRESSION;
	const value = keyProp.exp || normalizeBindShorthand(keyProp.arg, context);
	if (isStaticExpression(value, context.options.bindingMetadata)) return resolveExpression(value, isComponent);
}
function createSetBlockKey(element, value) {
	return {
		type: 2,
		element,
		value
	};
}
function buildProps(node, context, isComponent, isDynamicComponent, getEffectIndex) {
	const props = node.props;
	if (props.length === 0) return [false, []];
	const dynamicArgs = [];
	const dynamicExpr = [];
	let results = [];
	const deferListeners = !isComponent && !!findDir$1(node, "model") && !hasDynamicKeyVBind(node) && mergesListeners(node, context);
	let listenerResults = [];
	function pushMergeArg(listeners = false) {
		const props = listeners ? listenerResults : results;
		if (props.length) {
			dynamicArgs.push(dedupeProperties(props));
			if (listeners) listenerResults = [];
			else results = [];
		}
	}
	function pushStaticObjectLiteralProps(props) {
		if (dynamicArgs.length) {
			pushMergeArg();
			dynamicArgs.push(props);
		} else results.push(...props.map(toDirectiveResult));
	}
	for (const prop of props) {
		if (prop.type === 7 && !prop.arg) {
			if (prop.name === "bind") {
				if (prop.exp) {
					const objectLiteralProps = isComponent ? resolveComponentObjectLiteralBindProps(prop.exp, context, props, prop) : resolveNativeObjectLiteralBindProps(prop.exp, context, props, prop);
					if (objectLiteralProps) {
						if (isComponent) pushStaticObjectLiteralProps(objectLiteralProps);
						else {
							dynamicExpr.push(prop.exp);
							results.push(...objectLiteralProps.map(toDirectiveResult));
						}
					} else {
						dynamicExpr.push(prop.exp);
						pushMergeArg();
						dynamicArgs.push({
							kind: 0,
							value: prop.exp
						});
					}
				} else context.options.onError(createCompilerError(34, prop.loc));
				continue;
			} else if (prop.name === "on") {
				if (prop.exp) {
					const objectLiteralProps = isComponent ? resolveComponentObjectLiteralOnProps(prop.exp, context, props, prop) : void 0;
					if (objectLiteralProps) pushStaticObjectLiteralProps(objectLiteralProps);
					else if (isComponent || mergesListeners(node, context)) {
						dynamicExpr.push(prop.exp);
						pushMergeArg(deferListeners);
						dynamicArgs.push({
							kind: 0,
							value: prop.exp,
							handler: true
						});
					} else context.registerEffect([prop.exp], {
						type: 7,
						element: context.reference(),
						event: prop.exp
					}, getEffectIndex);
				} else context.options.onError(createCompilerError(35, prop.loc));
				continue;
			}
		}
		if (prop.type === 6 ? prop.name === "is" && (isDynamicComponent || isVueIsValue(prop)) : isDynamicComponent && prop.name === "bind" && isStaticArgOf(prop.arg, "is")) continue;
		const result = transformProp(prop, node, context);
		if (result) {
			if (deferListeners && !result.handler && (result.modifier || !isOn(result.key.content))) {
				results.push(result);
				continue;
			}
			dynamicExpr.push(result.key);
			if (!deferListeners || !result.handler) dynamicExpr.push(result.value);
			if (deferListeners) listenerResults.push(result);
			else if (isComponent && !result.key.isStatic) {
				pushMergeArg();
				dynamicArgs.push(extend(resolveDirectiveResult(result), { kind: 1 }));
			} else results.push(result);
		}
	}
	if (deferListeners) {
		pushMergeArg(true);
		context.registerEffect(dynamicExpr, {
			type: 4,
			element: context.reference(),
			props: dynamicArgs,
			isSVG: node.ns === 1,
			listeners: true
		}, getEffectIndex);
		return [false, dedupeProperties(results)];
	}
	if (dynamicArgs.length || results.some(({ key }) => !key.isStatic)) {
		pushMergeArg();
		return [
			true,
			dynamicArgs,
			dynamicExpr
		];
	}
	return [false, dedupeProperties(results)];
}
function resolveObjectLiteralProps(exp, context, keyTransform, isValidKey) {
	const ast = exp.ast;
	if (!ast || ast.type !== "ObjectExpression") return;
	const props = [];
	const knownKeys = /* @__PURE__ */ new Set();
	for (const property of ast.properties) {
		if (property.type !== "ObjectProperty" || property.computed) return;
		let key = getObjectPropertyName(property);
		if (key == null || key === "__proto__") return;
		if (isValidKey && !isValidKey(key)) return;
		if (keyTransform) key = keyTransform(key);
		if (knownKeys.has(key)) return;
		knownKeys.add(key);
		props.push({
			key: createSimpleExpression(key, true),
			values: [resolveExpression(createObjectBindSubExpression(exp, property.value, context), true)]
		});
	}
	return props;
}
function resolveComponentObjectLiteralBindProps(exp, context, nodeProps, currentProp) {
	const props = resolveObjectLiteralProps(exp, context, void 0, isSafeObjectLiteralBindKey);
	if (!props || hasComponentObjectLiteralBindConflict(nodeProps, currentProp, props)) return;
	return props;
}
const listenerMerge = /* @__PURE__ */ new WeakMap();
function mergesListeners(node, context) {
	let merges = listenerMerge.get(node);
	if (merges === void 0) listenerMerge.set(node, merges = resolveListenerMerge(node, context));
	return merges;
}
function resolveListenerMerge(node, context) {
	const props = node.props;
	let hasVOnObject = false;
	let hasStaticListener = false;
	for (const p of props) {
		if (p.type !== 7) continue;
		const arg = p.arg && resolveExpression(p.arg);
		if (p.name === "bind") {
			if (!arg) {
				if (p.exp) {
					const bindProps = resolveNativeObjectLiteralBindProps(p.exp, context, props, p);
					if (!bindProps) return true;
					if (node.ns === 1 && bindProps.some(({ key }) => isNativeOn(key.content))) hasStaticListener = true;
				}
			} else if (!arg.isStatic) return true;
			else if ((isOn(arg.content) || node.ns === 1 && isNativeOn(arg.content)) && !isModelListener(arg.content) && !p.modifiers.some((m) => m.content === "prop" || m.content === "attr")) hasStaticListener = true;
		} else if (p.name === "on") {
			if (!arg) hasVOnObject = true;
			else if (arg.isStatic && !p.modifiers.some((m) => m.content === "delegate")) hasStaticListener = true;
		}
	}
	return hasVOnObject && hasStaticListener;
}
function resolveNativeObjectLiteralBindProps(exp, context, nodeProps, currentProp) {
	const props = resolveObjectLiteralProps(exp, context, void 0, isSafeNativeObjectLiteralBindKey);
	if (!props || hasNativeObjectLiteralBindConflict(nodeProps, currentProp, props)) return;
	return props;
}
function resolveComponentObjectLiteralOnProps(exp, context, nodeProps, currentProp) {
	const props = resolveObjectLiteralProps(exp, context, toHandlerKey);
	if (!props || hasComponentObjectLiteralBindConflict(nodeProps, currentProp, props)) return;
	return props;
}
function isSafeNativeObjectLiteralBindKey(key) {
	return key !== "" && !UNSAFE_ATTR_NAME_RE.test(key) && isSafeObjectLiteralBindKey(key) && !isOn(key) && key.charCodeAt(0) !== 46 && key.charCodeAt(0) !== 94;
}
function isSafeObjectLiteralBindKey(key) {
	return !isReservedProp(key);
}
function hasComponentObjectLiteralBindConflict(props, currentProp, objectLiteralProps) {
	const keys = createComponentConflictKeySet(objectLiteralProps.map((prop) => prop.key.content));
	for (const prop of props) {
		if (prop === currentProp) continue;
		let key;
		if (prop.type === 6) key = prop.name;
		else if (prop.name === "bind") {
			if (!prop.arg) {
				const bindKeys = getObjectLiteralKeys(prop.exp);
				if (bindKeys && hasComponentKeyOverlap(keys, bindKeys)) return true;
				continue;
			}
			key = getStaticBindKey(prop);
		} else if (prop.name === "on") key = getStaticHandlerKey(prop);
		else if (prop.name === "model") {
			if (hasComponentModelKey(keys, prop)) return true;
		}
		if (key && hasComponentKey(keys, key)) return true;
	}
	return false;
}
function hasComponentModelKey(keys, prop) {
	const { arg } = prop;
	if (arg && (arg.type !== 4 || !arg.isStatic)) return true;
	const key = arg ? arg.content : "modelValue";
	return hasComponentKey(keys, key) || hasComponentKey(keys, `onUpdate:${camelize(key)}`) || prop.modifiers.length > 0 && hasComponentKey(keys, getModifierPropName(key));
}
function hasNativeObjectLiteralBindConflict(props, currentProp, objectLiteralProps) {
	const keys = new Set(objectLiteralProps.map((prop) => prop.key.content));
	for (const prop of props) {
		if (prop === currentProp) continue;
		let key;
		if (prop.type === 6) key = prop.name;
		else if (prop.name === "bind") {
			if (!prop.arg) return true;
			key = getStaticBindKey(prop);
			if (!key) return true;
		}
		if (key && keys.has(key)) return true;
	}
	return false;
}
function getStaticBindKey(prop) {
	const { arg } = prop;
	if (!arg || arg.type !== 4 || !arg.isStatic) return;
	let key = arg.content;
	if (isReservedProp(key)) return;
	if (prop.modifiers.some((modifier) => modifier.content === "camel")) key = camelize(key);
	return key;
}
function getStaticHandlerKey(prop) {
	const { arg } = prop;
	if (!arg || arg.type !== 4 || !arg.isStatic) return;
	let key = arg.content;
	if (key.startsWith("vue:")) key = `vnode-${key.slice(4)}`;
	const { nonKeyModifiers, eventOptionModifiers } = resolveModifiers(`on${key}`, prop.modifiers, null, prop.loc);
	if (key.toLowerCase() === "click") {
		if (nonKeyModifiers.includes("middle")) key = "mouseup";
		if (nonKeyModifiers.includes("right")) key = "contextmenu";
	}
	key = toHandlerKey(camelize(key));
	const optionPostfix = eventOptionModifiers.map(capitalize).join("");
	if (optionPostfix) key += optionPostfix;
	return key;
}
function getObjectLiteralKeys(exp) {
	const ast = exp && exp.ast;
	if (!ast || ast.type !== "ObjectExpression") return;
	const keys = /* @__PURE__ */ new Set();
	for (const property of ast.properties) {
		if (property.type !== "ObjectProperty" || property.computed) return;
		const key = getObjectPropertyName(property);
		if (key == null) return;
		keys.add(key);
	}
	return keys;
}
function createComponentConflictKeySet(keys) {
	const normalized = /* @__PURE__ */ new Set();
	for (const key of keys) {
		normalized.add(key);
		normalized.add(camelize(key));
	}
	return normalized;
}
function hasComponentKey(keys, key) {
	return keys.has(key) || keys.has(camelize(key));
}
function hasComponentKeyOverlap(left, right) {
	for (const key of right) if (hasComponentKey(left, key)) return true;
	return false;
}
function createObjectBindSubExpression(source, node, context) {
	const start = node.start == null ? 0 : node.start - 1;
	const end = node.end == null ? source.content.length : node.end - 1;
	const content = source.content.slice(start, end);
	const expression = createSimpleExpression(content, false, {
		start: advancePositionWithClone(source.loc.start, source.content, start),
		end: advancePositionWithClone(source.loc.start, source.content, end),
		source: content
	});
	expression.ast = isSimpleIdentifier(content) ? null : (0, import_lib.parseExpression)(`(${content})`, getParserOptions(context.options.expressionPlugins));
	return expression;
}
function transformProp(prop, node, context) {
	let { name } = prop;
	if (prop.type === 6) {
		if (isReservedProp(name)) return;
		return {
			key: createSimpleExpression(prop.name, true, prop.nameLoc),
			value: prop.value ? createSimpleExpression(prop.value.content, true, prop.value.loc) : EMPTY_EXPRESSION
		};
	}
	const directiveTransform = context.options.directiveTransforms[name];
	if (directiveTransform) return directiveTransform(prop, node, context);
	if (!isBuiltInDirective(name)) {
		if (node.tagType === 2) {
			context.options.onError(createCompilerError(36, prop.loc));
			return;
		}
		const fromSetup = resolveSetupReference(`v-${name}`, context);
		if (fromSetup) name = fromSetup;
		else context.directive.add(name);
		context.registerOperation({
			type: 13,
			element: context.reference(),
			dir: prop,
			name,
			asset: !fromSetup,
			once: context.inVOnce
		});
	}
}
function dedupeProperties(results) {
	const knownProps = /* @__PURE__ */ new Map();
	const deduped = [];
	for (const result of results) {
		const prop = resolveDirectiveResult(result);
		if (!prop.key.isStatic) {
			deduped.push(prop);
			continue;
		}
		const name = prop.key.content;
		const existing = knownProps.get(name);
		if (existing && existing.handler === prop.handler) {
			if (prop.handler) deduped.push(prop);
			else if (name === "style" || name === "class") mergePropValues(existing, prop);
		} else {
			knownProps.set(name, prop);
			deduped.push(prop);
		}
	}
	return deduped;
}
function resolveDirectiveResult(prop) {
	return extend({}, prop, {
		value: void 0,
		values: [prop.value]
	});
}
function toDirectiveResult(prop) {
	return extend({}, prop, {
		values: void 0,
		value: prop.values[0]
	});
}
function mergePropValues(existing, incoming) {
	const newValues = incoming.values;
	existing.values.push(...newValues);
}
function shouldUseCreateElement(node, context) {
	return context.options.isCustomElement(node.tag) || node.tagType === 0 && node.tag === "template";
}
//#endregion
//#region packages/compiler-vapor/src/transforms/transformChildren.ts
const transformChildren = (node, context) => {
	const isFragment = node.type === 0 || node.type === 1 && (node.tagType === 3 || node.tagType === 1);
	if (!isFragment && node.type !== 1) return;
	const useCreateElement = node.type === 1 && shouldUseCreateElement(node, context);
	const childTemplateCloseState = !isFragment && !useCreateElement ? getChildTemplateCloseState(context) : void 0;
	for (const [i, child] of node.children.entries()) {
		const childContext = context.create(child, i);
		const isInSameTemplate = childTemplateCloseState && child.type === 1 && child.tagType === 0 && isInSameTemplateAsParent(childContext);
		childContext.templateCloseTags = isInSameTemplate ? childTemplateCloseState.tags : void 0;
		childContext.templateCloseBlocks = isInSameTemplate ? childTemplateCloseState.blocks : false;
		transformNode(childContext);
		const childDynamic = childContext.dynamic;
		const createsNode = isFragment || childContext.template !== "" || childDynamic.template != null || childDynamic.id !== void 0 || childDynamic.operation !== void 0 || childDynamic.hasDynamicChild === true;
		if (isFragment) {
			childContext.reference();
			childContext.registerTemplate();
			if (!(childDynamic.flags & 2) || childDynamic.flags & 4) context.block.returns.push(childContext.dynamic.id);
		} else if (useCreateElement) {
			if (createsNode) {
				childContext.reference();
				childContext.registerTemplate();
				childDynamic.flags |= 6;
			}
		} else context.childrenTemplate.push(childContext.template);
		if (childDynamic.hasDynamicChild || childDynamic.id !== void 0 || childDynamic.flags & 2 || childDynamic.flags & 4) context.dynamic.hasDynamicChild = true;
		if (!createsNode) childDynamic.flags |= 2;
		context.dynamic.children[i] = childDynamic;
	}
	if (!isFragment) processDynamicChildren(context, useCreateElement);
};
function processDynamicChildren(context, useCreateElement) {
	const children = context.dynamic.children;
	let lastTemplateIndex = -1;
	for (let i = children.length - 1; i >= 0; i--) if (!(children[i].flags & 2)) {
		lastTemplateIndex = i;
		break;
	}
	let unitIndex = 0;
	for (const [index, child] of children.entries()) if (child.flags & 4) {
		let anchor;
		if (index < lastTemplateIndex) {
			context.childrenTemplate[index] = `<!>`;
			child.flags = child.flags - 2 | 1;
			anchor = child.anchor = context.increaseId();
		}
		if (child.template != null) child.operation = {
			type: 10,
			elements: [child.id],
			parent: context.reference(),
			anchor,
			appendIndex: useCreateElement ? unitIndex : void 0
		};
		else if (child.operation && isBlockOperation(child.operation)) {
			child.operation.parent = context.reference();
			if (anchor !== void 0) child.operation.anchor = anchor;
			else child.operation.appendIndex = unitIndex;
		}
		unitIndex++;
	} else if (!(child.flags & 2)) unitIndex++;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vOnce.ts
const transformVOnce = (node, context) => {
	if (node.type === 1 && findDir$1(node, "once", true)) context.inVOnce = true;
};
//#endregion
//#region packages/compiler-vapor/src/transforms/transformText.ts
const seen = /* @__PURE__ */ new WeakMap();
function markNonTemplate(node, context) {
	let seenNodes = seen.get(context.root);
	if (!seenNodes) {
		seenNodes = /* @__PURE__ */ new WeakSet();
		seen.set(context.root, seenNodes);
	}
	seenNodes.add(node);
}
const transformText = (node, context) => {
	if (!seen.has(context.root)) seen.set(context.root, /* @__PURE__ */ new WeakSet());
	if (seen.get(context.root).has(node)) {
		context.dynamic.flags |= 2;
		return;
	}
	const isFragment = node.type === 0 || node.type === 1 && (node.tagType === 3 || node.tagType === 1);
	if ((isFragment || node.type === 1 && node.tagType === 0) && node.children.length) {
		let hasInterp = false;
		let isAllTextLike = true;
		for (const c of node.children) if (c.type === 5) hasInterp = true;
		else if (c.type !== 2) isAllTextLike = false;
		if (!isFragment && isAllTextLike && hasInterp) {
			const elementContext = context;
			if (shouldUseCreateElement(node, elementContext)) processCreateElementTextContainer(node.children, elementContext);
			else processTextContainer(node.children, elementContext);
		} else if (hasInterp) for (let i = 0; i < node.children.length; i++) {
			const c = node.children[i];
			const prev = node.children[i - 1];
			if (c.type === 5 && prev && prev.type === 2) markNonTemplate(prev, context);
		}
	} else if (node.type === 5) processInterpolation(context);
	else if (node.type === 2) {
		var _context$parent;
		const parent = (_context$parent = context.parent) === null || _context$parent === void 0 ? void 0 : _context$parent.node;
		const createElementParent = parent && parent.type === 1 && shouldUseCreateElement(parent, context.parent);
		const isRootText = !parent || parent.type === 0 || parent.type === 1 && (parent.tagType === 3 || parent.tagType === 1);
		const isRawText = createElementParent || isRootText;
		if (isRawText && node.content[0] === "<") {
			materializeLiteralTextNode(createSimpleExpression(node.content, true, node.loc), context);
			return;
		}
		context.template += isRawText ? node.content : escapeHtml(node.content);
	}
};
function processInterpolation(context) {
	const parentNode = context.parent.node;
	const values = processTextLikeChildren(collectAdjacentText(context), context);
	if (values.length === 0 && parentNode.type !== 0) return;
	const literalValues = values.map((v) => getLiteralExpressionValue(v));
	const text = literalValues.every((v) => v != null) ? literalValues.join("") : null;
	const isElementChild = parentNode.type === 1 && parentNode.tagType === 0;
	if (text !== null && parentNode.type !== 0 && (isElementChild || text !== "")) {
		const isRawText = !isElementChild || parentNode.type === 1 && shouldUseCreateElement(parentNode, context.parent);
		if (isRawText && text[0] === "<") {
			materializeLiteralTextNode(createSimpleExpression(text, true, context.node.loc), context);
			return;
		}
		context.template += isRawText ? text : escapeHtml(text);
		return;
	}
	context.template += " ";
	const id = context.reference();
	context.dynamic.isText = isElementChild;
	if (values.length === 0) return;
	context.registerEffect(values, {
		type: 5,
		element: id,
		values
	});
}
function collectAdjacentText(context) {
	const children = context.parent.node.children;
	const nodes = [];
	const prev = children[context.index - 1];
	let index = prev && prev.type === 2 ? context.index - 1 : context.index;
	for (; index < children.length; index++) {
		const child = children[index];
		if (!isTextLike(child)) break;
		nodes.push(child);
	}
	return nodes;
}
function processTextContainer(children, context) {
	const values = processTextLikeChildren(children, context);
	const literals = values.map((value) => getLiteralExpressionValue(value));
	if (literals.every((l) => l != null)) context.childrenTemplate = literals.map((l) => escapeHtml(String(l)));
	else {
		context.childrenTemplate = [" "];
		context.registerOperation({
			type: 17,
			parent: context.reference()
		});
		context.registerEffect(values, {
			type: 5,
			element: context.reference(),
			values,
			generated: true
		});
	}
}
function registerSyntheticTextChild(context, template, values) {
	const id = context.increaseId();
	context.dynamic.children[context.node.children.length] = {
		id,
		flags: 6,
		children: [],
		template: context.pushTemplate(template)
	};
	context.dynamic.hasDynamicChild = true;
	if (values && values.length) context.registerEffect(values, {
		type: 5,
		element: id,
		values
	});
	return id;
}
function processCreateElementTextContainer(children, context) {
	registerSyntheticTextChild(context, "", processTextLikeChildren(children, context));
}
function materializeLiteralTextNode(value, context) {
	const id = context.reference();
	context.dynamic.flags |= 6;
	context.dynamic.template = context.pushTemplate("");
	context.registerEffect([value], {
		type: 5,
		element: id,
		values: [value]
	});
}
function processTextLikeChildren(nodes, context) {
	const exps = [];
	for (const node of nodes) {
		let exp;
		markNonTemplate(node, context);
		if (node.type === 2) exp = createSimpleExpression(node.content, true, node.loc);
		else exp = node.content;
		if (exp.content) exps.push(exp);
	}
	return exps;
}
function isTextLike(node) {
	return node.type === 5 || node.type === 2;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vText.ts
const isRawTextContainer = /*@__PURE__*/ makeMap("iframe,noembed,noframes,noscript,script,style,xmp");
const transformVText = (dir, node, context) => {
	let { exp, loc } = dir;
	if (!exp) {
		context.options.onError(createDOMCompilerError(56, loc));
		exp = EMPTY_EXPRESSION;
	}
	if (node.children.length) {
		context.options.onError(createDOMCompilerError(57, loc));
		context.childrenTemplate.length = 0;
		for (const child of node.children) markNonTemplate(child, context);
	}
	if (isVoidTag(context.node.tag)) return;
	if (node.tagType === 1) return {
		key: createSimpleExpression("textContent", true),
		value: exp,
		toDisplayString: !isConstantVTextExpression(exp, context.options.bindingMetadata)
	};
	const literal = getLiteralExpressionValue(exp);
	const useCreateElement = shouldUseCreateElement(context.node, context);
	if (literal != null) {
		if (useCreateElement || isRawTextContainer(node.tag)) {
			const id = registerSyntheticTextChild(context, "", [exp]);
			context.registerOperation({
				type: 10,
				elements: [id],
				parent: context.reference()
			});
		} else context.childrenTemplate = [escapeHtml(literal)];
	} else {
		let id;
		if (useCreateElement) {
			id = registerSyntheticTextChild(context, "");
			context.registerOperation({
				type: 10,
				elements: [id],
				parent: context.reference()
			});
		} else {
			context.childrenTemplate = [" "];
			context.registerOperation({
				type: 17,
				parent: context.reference()
			});
		}
		context.registerEffect([exp], {
			type: 5,
			element: useCreateElement ? id : context.reference(),
			values: [exp],
			generated: !useCreateElement
		});
	}
};
function isConstantVTextExpression(exp, bindings) {
	if (isConstantExpression(exp)) return true;
	if (exp.ast === null) {
		const type = bindings[exp.content];
		return type === "setup-const" || type === "literal-const";
	}
	if (!exp.ast) return false;
	let isConstant = true;
	walkIdentifiers(exp.ast, (id, parent, _parentStack, isReferenced) => {
		if (parent && isStaticPropertyKey(id, parent)) return;
		if (isReferenced && !isGloballyAllowed(id.name) && id.name !== "require" || (parent === null || parent === void 0 ? void 0 : parent.type) === "CallExpression" || (parent === null || parent === void 0 ? void 0 : parent.type) === "NewExpression" || (parent === null || parent === void 0 ? void 0 : parent.type) === "MemberExpression") isConstant = false;
	}, true);
	return isConstant;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vOn.ts
const delegatedEvents = /*#__PURE__*/ makeMap("beforeinput,click,dblclick,contextmenu,focusin,focusout,input,keydown,keyup,mousedown,mousemove,mouseout,mouseover,mouseup,pointerdown,pointermove,pointerout,pointerover,pointerup,touchend,touchmove,touchstart");
const transformVOn = (dir, node, context) => {
	let { arg, exp, loc, modifiers } = dir;
	const isComponent = node.tagType === 1;
	const isSlotOutlet = node.tag === "slot";
	if (!exp && !modifiers.length) context.options.onError(createCompilerError(35, loc));
	let delegateModifier;
	let nonDelegateModifiers;
	for (let i = 0; i < modifiers.length; i++) {
		const modifier = modifiers[i];
		if (modifier.content === "delegate") {
			delegateModifier || (delegateModifier = modifier);
			nonDelegateModifiers || (nonDelegateModifiers = modifiers.slice(0, i));
		} else if (nonDelegateModifiers) nonDelegateModifiers.push(modifier);
	}
	if (nonDelegateModifiers) modifiers = nonDelegateModifiers;
	arg = resolveExpression(arg);
	if (arg.isStatic && arg.content.startsWith("vue:")) arg = extend({}, arg, { content: `vnode-${arg.content.slice(4)}` });
	const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(arg.isStatic ? `on${arg.content}` : arg, modifiers, null, loc);
	let keyOverride;
	const isStaticClick = arg.isStatic && arg.content.toLowerCase() === "click";
	if (nonKeyModifiers.includes("right")) {
		if (!isStaticClick && !arg.isStatic) keyOverride = ["click", "contextmenu"];
	} else if (nonKeyModifiers.includes("middle")) {
		if (!isStaticClick && !arg.isStatic) keyOverride = ["click", "mouseup"];
	}
	arg = normalizeStaticEventArg(arg, nonKeyModifiers);
	if (keyModifiers.length && isStaticExp(arg) && !isKeyboardEvent(`on${arg.content.toLowerCase()}`)) keyModifiers.length = 0;
	if (isComponent || isSlotOutlet || !delegateModifier && arg.isStatic && mergesListeners(node, context)) {
		if (delegateModifier) warnDelegate(context, delegateModifier, ".delegate modifier is only supported on native DOM elements. The modifier will be ignored.");
		return {
			key: arg,
			value: exp || EMPTY_EXPRESSION,
			handler: true,
			handlerModifiers: {
				keys: keyModifiers,
				nonKeys: nonKeyModifiers,
				options: eventOptionModifiers
			}
		};
	}
	const isDelegatableEvent = !!delegateModifier && arg.isStatic && delegatedEvents(arg.content);
	const hasStopHandler = isDelegatableEvent && !eventOptionModifiers.length && hasStopHandlerForStaticEvent(node, arg.content);
	if (delegateModifier && !arg.isStatic) warnDelegate(context, delegateModifier, ".delegate modifier requires a static event name. The listener will be attached directly.");
	else if (delegateModifier && !isDelegatableEvent) warnDelegate(context, delegateModifier, `.delegate modifier is not supported on the "${arg.content}" event. The listener will be attached directly.`);
	const delegate = isDelegatableEvent && !eventOptionModifiers.length && !hasStopHandler;
	const operation = {
		type: 6,
		element: context.reference(),
		key: arg,
		value: exp,
		modifiers: {
			keys: keyModifiers,
			nonKeys: nonKeyModifiers,
			options: eventOptionModifiers
		},
		keyOverride,
		delegate,
		effect: !arg.isStatic
	};
	context.registerEffect([arg], operation);
};
function normalizeStaticEventArg(arg, nonKeyModifiers) {
	if (!arg.isStatic) return arg;
	let normalized = arg;
	const isStaticClick = arg.content.toLowerCase() === "click";
	if (nonKeyModifiers.includes("right") && isStaticClick) normalized = extend({}, normalized, { content: "contextmenu" });
	else if (nonKeyModifiers.includes("middle") && isStaticClick) normalized = extend({}, normalized, { content: "mouseup" });
	return normalized;
}
function hasStopHandlerForStaticEvent(node, eventName) {
	return node.props.some((prop) => {
		if (prop.type !== 7 || prop.name !== "on" || !prop.arg || prop.arg.type !== 4) return false;
		const arg = resolveExpression(prop.arg);
		if (!arg.isStatic) return false;
		const { nonKeyModifiers } = resolveModifiers(`on${arg.content}`, prop.modifiers, null, prop.loc);
		return nonKeyModifiers.includes("stop") && normalizeStaticEventArg(arg, nonKeyModifiers).content === eventName;
	});
}
function warnDelegate(context, modifier, message) {
	const error = new SyntaxError(message);
	error.loc = modifier.loc;
	context.options.onWarn(error);
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vShow.ts
const transformVShow = (dir, node, context) => {
	const { exp, loc } = dir;
	if (!exp) {
		context.options.onError(createDOMCompilerError(62, loc));
		return;
	}
	if (node.tagType === 2) {
		context.options.onError(createCompilerError(36, loc));
		return;
	}
	context.registerOperation({
		type: 13,
		element: context.reference(),
		dir,
		name: "show",
		builtin: true,
		once: context.inVOnce
	});
};
//#endregion
//#region packages/compiler-vapor/src/transforms/transformTemplateRef.ts
const transformTemplateRef = (node, context) => {
	if (node.type !== 1) return;
	const dir = findProp(node, "ref", false, true);
	if (!dir) return;
	context.ir.hasTemplateRef = true;
	let value;
	if (dir.type === 7) value = dir.exp || normalizeBindShorthand(dir.arg, context);
	else value = dir.value ? createSimpleExpression(dir.value.content, true, dir.value.loc) : EMPTY_EXPRESSION;
	return () => {
		const id = context.reference();
		const effect = !isConstantExpression(value);
		context.registerEffect([value], {
			type: 9,
			element: id,
			value,
			refFor: !!context.inVFor,
			effect
		});
	};
};
//#endregion
//#region packages/compiler-vapor/src/transforms/vModel.ts
const transformVModel = (dir, node, context) => {
	const { exp, arg } = dir;
	if (!exp) {
		context.options.onError(createCompilerError(41, dir.loc));
		return;
	}
	const rawExp = exp.loc.source;
	const bindingType = context.options.bindingMetadata[rawExp];
	if (bindingType === "props" || bindingType === "props-aliased") {
		context.options.onError(createCompilerError(44, exp.loc));
		return;
	}
	const expString = exp.content;
	const maybeRef = context.options.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
	if (!expString.trim() || !isMemberExpression$1(exp, context.options) && !maybeRef) {
		context.options.onError(createCompilerError(42, exp.loc));
		return;
	}
	if (node.tagType === 1) return {
		key: arg ? arg : createSimpleExpression("modelValue", true),
		value: exp,
		model: true,
		modelModifiers: dir.modifiers.map((m) => m.content)
	};
	if (dir.arg) context.options.onError(createDOMCompilerError(59, dir.arg.loc));
	const { tag } = node;
	const isCustomElement = context.options.isCustomElement(tag);
	let modelType = "text";
	if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
		if (tag === "input" || isCustomElement) {
			const type = findProp$1(node, "type");
			if (type) {
				if (type.type === 7) modelType = "dynamic";
				else if (type.value) switch (type.value.content) {
					case "radio":
						modelType = "radio";
						break;
					case "checkbox":
						modelType = "checkbox";
						break;
					case "file":
						modelType = void 0;
						context.options.onError(createDOMCompilerError(60, dir.loc));
						break;
					default: checkDuplicatedValue();
				}
			} else if (hasDynamicKeyVBind(node)) modelType = "dynamic";
			else checkDuplicatedValue();
		} else if (tag === "select") modelType = "select";
		else checkDuplicatedValue();
	} else context.options.onError(createDOMCompilerError(58, dir.loc));
	if (modelType) context.registerOperation({
		type: 13,
		element: context.reference(),
		dir,
		name: "model",
		modelType,
		builtin: true,
		once: context.inVOnce
	});
	function checkDuplicatedValue() {
		const value = findDir$1(node, "bind");
		if (value && isStaticArgOf(value.arg, "value")) context.options.onError(createDOMCompilerError(61, value.loc));
	}
};
//#endregion
//#region packages/compiler-vapor/src/transforms/transformComment.ts
const ignoredComments = /* @__PURE__ */ new WeakMap();
function ignoreComment(node, context) {
	let ignored = ignoredComments.get(context.root);
	if (!ignored) ignoredComments.set(context.root, ignored = /* @__PURE__ */ new WeakSet());
	ignored.add(node);
}
const transformComment = (node, context) => {
	var _ignoredComments$get;
	if (node.type !== 3) return;
	if ((_ignoredComments$get = ignoredComments.get(context.root)) === null || _ignoredComments$get === void 0 ? void 0 : _ignoredComments$get.has(node)) context.dynamic.flags |= 2;
	else if (getSiblingIf(context)) {
		context.comment.push(node);
		context.dynamic.flags |= 2;
	} else context.template += `<!--${node.content}-->`;
};
function getSiblingIf(context, reverse) {
	const parent = context.parent;
	if (!parent) return;
	const siblings = parent.node.children;
	let sibling;
	let i = siblings.indexOf(context.node);
	while (reverse ? --i >= 0 : ++i < siblings.length) {
		sibling = siblings[i];
		if (!isCommentOrWhitespace(sibling)) break;
	}
	if (sibling && sibling.type === 1 && sibling.props.some(({ type, name }) => type === 7 && ["else-if", reverse ? "if" : "else"].includes(name))) return sibling;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vIf.ts
init_objectSpread2();
const transformVIf = createStructuralDirectiveTransform([
	"if",
	"else",
	"else-if"
], processIf);
function processIf(node, dir, context) {
	if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
		const loc = dir.exp ? dir.exp.loc : node.loc;
		context.options.onError(createCompilerError(28, dir.loc));
		dir.exp = createSimpleExpression(`true`, false, loc);
	}
	context.dynamic.flags |= 2;
	const forceMultiRoot = shouldForceMultiRoot(context);
	const allowNoScope = context.block === context.root.block;
	if (dir.name === "if") {
		const id = context.reference();
		context.dynamic.flags |= 4;
		const [branch, onExit] = createIfBranch(node, context);
		return () => {
			onExit();
			context.dynamic.operation = _objectSpread2(_objectSpread2({
				type: 14,
				id
			}, context.effectBoundary()), {}, {
				blockShape: encodeIfBlockShape(branch, forceMultiRoot, void 0, allowNoScope),
				condition: dir.exp,
				positive: branch,
				index: context.root.nextIfIndex(),
				once: context.inVOnce || isStaticExpression(dir.exp, context.options.bindingMetadata)
			});
		};
	} else {
		const siblingIf = getSiblingIf(context, true);
		const siblings = context.parent && context.parent.dynamic.children;
		let lastIfNode;
		if (siblings) {
			let i = siblings.length;
			while (i--) if (siblings[i].operation && siblings[i].operation.type === 14) {
				lastIfNode = siblings[i].operation;
				break;
			}
		}
		if (!siblingIf || !lastIfNode || lastIfNode.type !== 14) {
			context.options.onError(createCompilerError(30, node.loc));
			return;
		}
		while (lastIfNode.negative && lastIfNode.negative.type === 14) lastIfNode = lastIfNode.negative;
		if (dir.name === "else-if" && lastIfNode.negative) context.options.onError(createCompilerError(30, node.loc));
		checkSameKey(node, context);
		const comments = context.comment;
		if (comments.length) {
			if (!isInTransition(context)) {
				node = wrapTemplate(node, ["else-if", "else"]);
				context.node = node = extend({}, node, { children: [...comments, ...node.children] });
			}
			comments.length = 0;
		}
		const [branch, onExit] = createIfBranch(node, context);
		if (dir.name === "else") lastIfNode.negative = branch;
		else lastIfNode.negative = {
			type: 14,
			id: -1,
			condition: dir.exp,
			positive: branch,
			index: context.root.nextIfIndex(),
			blockShape: 0,
			once: context.inVOnce || isStaticExpression(dir.exp, context.options.bindingMetadata)
		};
		return () => {
			onExit();
			if (lastIfNode.negative.type === 14) lastIfNode.negative.blockShape = encodeIfBlockShape(lastIfNode.negative.positive, forceMultiRoot, void 0, allowNoScope);
			lastIfNode.blockShape = encodeIfBlockShape(lastIfNode.positive, forceMultiRoot, lastIfNode.negative, allowNoScope);
		};
	}
}
function createIfBranch(node, context) {
	context.node = node = wrapTemplate(node, [
		"if",
		"else-if",
		"else"
	]);
	const branch = newBlock(node);
	const exitBlock = context.enterBlock(branch);
	context.reference();
	return [branch, exitBlock];
}
function encodeIfBlockShape(positive, forceMultiRoot = false, negative, allowNoScope = true) {
	if (forceMultiRoot) return 10;
	const positiveNoScope = allowNoScope && canSkipIfBranchScope(positive);
	const negativeNoScope = allowNoScope && negative && negative.type !== 14 && canSkipIfBranchScope(negative);
	return getBlockShape(positive) | getNegativeIfBranchShape(negative) << 2 | (positiveNoScope ? 32 : 0) | (negativeNoScope ? 64 : 0);
}
function getNegativeIfBranchShape(negative) {
	if (!negative) return 0;
	return negative.type === 14 ? 1 : getBlockShape(negative);
}
function canSkipIfBranchScope(block) {
	if (block.effect.length || block.operation.length) return false;
	if (!isStaticBranch(block.node)) return false;
	if (block.returns.length === 0 || block.dynamic.children.length !== block.returns.length) return false;
	return block.returns.every((id) => {
		const returned = findReturnedDynamic(block, id);
		return !!(returned && returned.template != null && !returned.operation && !returned.hasDynamicChild && !(returned.flags & 6));
	});
}
function findReturnedDynamic(block, id) {
	return block.dynamic.children.find((child) => child.id === id);
}
function isStaticBranch(node) {
	if (node.type !== 1 || node.tagType !== 3 || node.children.length === 0) return false;
	return node.children.every((child) => isStaticTemplateNode(child));
}
function isStaticTemplateNode(node) {
	if (node.type === 2 || node.type === 3) return true;
	if (node.type !== 1 || node.tagType !== 0) return false;
	for (const prop of node.props) if (prop.type === 7 || prop.name === "ref") return false;
	return node.children.every((child) => isStaticTemplateNode(child));
}
function shouldForceMultiRoot(context) {
	const parent = context.parent && context.parent.node;
	return !!parent && parent.type === 1 && parent.tagType === 3 && parent.props.some((prop) => prop.type === 7 && prop.name === "for");
}
function checkSameKey(node, context) {
	const key = findProp(node, "key");
	const parent = context.parent;
	if (!key || !parent) return;
	const siblings = parent.node.children;
	let i = siblings.indexOf(node);
	while (i > 0) {
		const sibling = siblings[--i];
		if (isCommentOrWhitespace(sibling)) continue;
		if (sibling.type !== 1) return;
		const dir = sibling.props.find((prop) => prop.type === 7 && (prop.name === "if" || prop.name === "else-if"));
		if (!dir) return;
		if (isSameKey(findProp(sibling, "key"), key)) context.options.onError(createCompilerError(29, key.loc));
		if (dir.name === "if") return;
	}
}
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;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vFor.ts
init_objectSpread2();
const transformVFor = createStructuralDirectiveTransform("for", processFor);
function processFor(node, dir, context) {
	if (!dir.exp) {
		context.options.onError(createCompilerError(31, dir.loc));
		return;
	}
	const parseResult = dir.forParseResult;
	if (!parseResult) {
		context.options.onError(createCompilerError(32, dir.loc));
		return;
	}
	const { source, value, key, index } = parseResult;
	const keyProp = findProp(node, "key", false, true);
	const keyProperty = keyProp && (keyProp.type === 6 ? keyProp.value && propToExpression(keyProp) : keyProp.exp || normalizeBindShorthand(keyProp.arg, context));
	const isComponent = node.tagType === 1 || isTemplateWithSingleComponent(node);
	const wrappedRows = node.tagType === 3 && !isInTransition(context) && (node.children.length !== 1 || node.children[0].type !== 1 || !!findDir(node.children[0], ROW_FRAGMENT_DIR_RE));
	context.node = node = wrapTemplate(node, ["for", "key"]);
	context.dynamic.flags |= 6;
	const id = context.reference();
	const render = newBlock(node);
	const exitBlock = context.enterBlock(render, true);
	context.reference();
	return () => {
		exitBlock();
		const { parent } = context;
		const isOnlyChild = parent && parent.block.node !== parent.node && parent.node.children.length === 1;
		context.dynamic.operation = _objectSpread2(_objectSpread2({
			type: 15,
			id
		}, context.effectBoundary()), {}, {
			source,
			value,
			key,
			index,
			keyProp: keyProperty,
			render,
			once: context.inVOnce || isStaticExpression(source, context.options.bindingMetadata),
			component: isComponent,
			onlyChild: !!isOnlyChild,
			wrappedRows
		});
	};
}
const ROW_FRAGMENT_DIR_RE = /^(?:if|for)$/;
function isTemplateWithSingleComponent(node) {
	if (node.tag !== "template") return false;
	const nonCommentChildren = node.children.filter((c) => c.type !== 3);
	return nonCommentChildren.length === 1 && nonCommentChildren[0].type === 1 && nonCommentChildren[0].tagType === 1;
}
//#endregion
//#region packages/compiler-vapor/src/transforms/transformSlotOutlet.ts
init_objectSpread2();
const transformSlotOutlet = (node, context) => {
	if (node.type !== 1 || node.tag !== "slot") return;
	const id = context.reference();
	context.dynamic.flags |= 6;
	const [fallback, exitBlock] = createFallback(node, context);
	let slotName;
	const slotProps = [];
	for (const prop of node.props) if (prop.type === 6) {
		if (prop.value) {
			if (prop.name === "name") slotName = createSimpleExpression(prop.value.content, true, prop.loc);
			else slotProps.push(extend({}, prop, { name: camelize(prop.name) }));
		}
	} else if (prop.name === "bind" && isStaticArgOf(prop.arg, "name")) {
		if (prop.exp) slotName = prop.exp;
		else {
			slotName = createSimpleExpression(camelize(prop.arg.content), false, prop.arg.loc);
			slotName.ast = null;
		}
	} else {
		let slotProp = prop;
		if (slotProp.name === "bind" && slotProp.arg && isStaticExp(slotProp.arg)) slotProp = extend({}, prop, { arg: extend({}, slotProp.arg, { content: camelize(slotProp.arg.content) }) });
		slotProps.push(slotProp);
	}
	slotName || (slotName = createSimpleExpression("default", true));
	let irProps = [];
	if (slotProps.length) {
		const [isDynamic, props] = buildProps(extend({}, node, { props: slotProps }), context, true);
		irProps = isDynamic ? props : [props];
	}
	return () => {
		exitBlock && exitBlock();
		let flags = 0;
		if (context.options.scopeId && !context.options.slotted) flags |= 1;
		if (context.inVOnce) flags |= 2;
		context.dynamic.operation = _objectSpread2(_objectSpread2({
			type: 12,
			id
		}, context.effectBoundary()), {}, {
			name: slotName,
			props: irProps,
			fallback,
			flags
		});
	};
};
function createFallback(node, context) {
	if (!node.children.length) return [];
	context.isSingleRoot = false;
	context.node = node = extend({}, node, {
		type: 1,
		tag: "template",
		props: [],
		tagType: 3,
		children: node.children
	});
	const fallback = newBlock(node);
	const exitBlock = context.enterBlock(fallback);
	context.reference();
	return [fallback, exitBlock];
}
//#endregion
//#region packages/compiler-vapor/src/transforms/vSlot.ts
const transformVSlot = (node, context) => {
	if (node.type !== 1) return;
	const dir = findDir(node, "slot", true);
	const { tagType, children } = node;
	const { parent } = context;
	const isComponent = tagType === 1;
	const isSlotTemplate = isTemplateNode(node) && parent && parent.node.type === 1 && parent.node.tagType === 1;
	if (isComponent && children.length) return transformComponentSlot(node, dir, context);
	else if (isSlotTemplate && dir) return transformTemplateSlot(node, dir, context);
	else if (!isComponent && dir) context.options.onError(createCompilerError(40, dir.loc));
};
function transformComponentSlot(node, dir, context) {
	const { children } = node;
	const arg = dir && dir.arg;
	const hasTemplateSlots = children.some(isSlotTemplateChild);
	const isTransitionHost = isTransitionHostNode(node);
	const emptyTextNodes = [];
	const nonSlotTemplateChildren = children.filter((n) => {
		if (isSlotTemplateChild(n)) return false;
		if (n.type === 3 && (hasTemplateSlots || isTransitionHost)) {
			ignoreComment(n, context);
			return false;
		}
		if (isNonWhitespaceContent(n)) return true;
		else {
			emptyTextNodes.push(n);
			return false;
		}
	});
	if (!nonSlotTemplateChildren.length) emptyTextNodes.forEach((n) => {
		markNonTemplate(n, context);
	});
	const [block, onExit] = createSlotBlock(node, dir, context);
	const { slots } = context;
	return () => {
		onExit();
		const hasOtherSlots = !!slots.length;
		if (dir && hasOtherSlots) {
			context.options.onError(createCompilerError(37, dir.loc));
			return;
		}
		if (nonSlotTemplateChildren.length) {
			if (hasStaticSlot(slots, "default")) context.options.onError(createCompilerError(39, nonSlotTemplateChildren[0].loc));
			else {
				registerSlot(slots, arg, block);
				context.slots = slots;
			}
		} else if (hasOtherSlots) context.slots = slots;
	};
}
function transformTemplateSlot(node, dir, context) {
	context.dynamic.flags |= 2;
	const resolvedArg = dir.arg && resolveExpression(dir.arg);
	let arg = resolvedArg;
	if (!arg) arg = createSimpleExpression("default", true);
	const vFor = findDir(node, "for");
	const vIf = findDir(node, "if");
	const vElse = findDir(node, /^else(-if)?$/, true);
	const { slots } = context;
	const [block, onExit] = createSlotBlock(node, dir, context);
	if (!vFor && !vIf && !vElse) {
		const slotName = resolvedArg ? resolvedArg.isStatic && resolvedArg.content : "default";
		if (slotName && hasStaticSlot(slots, slotName)) context.options.onError(createCompilerError(38, dir.loc));
		else registerSlot(slots, arg, block);
	} else if (vIf) registerDynamicSlot(slots, {
		slotType: 3,
		condition: vIf.exp,
		positive: {
			slotType: 1,
			name: arg,
			fn: block
		}
	});
	else if (vElse) {
		const vIfSlot = slots[slots.length - 1];
		if (vIfSlot && vIfSlot.slotType === 3) {
			let ifNode = vIfSlot;
			while (ifNode.negative && ifNode.negative.slotType === 3) ifNode = ifNode.negative;
			const negative = vElse.exp ? {
				slotType: 3,
				condition: vElse.exp,
				positive: {
					slotType: 1,
					name: arg,
					fn: block
				}
			} : {
				slotType: 1,
				name: arg,
				fn: block
			};
			ifNode.negative = negative;
		} else context.options.onError(createCompilerError(30, vElse.loc));
	} else if (vFor) {
		if (vFor.forParseResult) {
			const keyProp = findProp(node, "key");
			registerDynamicSlot(slots, {
				slotType: 2,
				name: arg,
				fn: block,
				loop: vFor.forParseResult,
				keyProp: keyProp && propToExpression(keyProp)
			});
		} else context.options.onError(createCompilerError(32, vFor.loc));
	}
	return onExit;
}
function ensureStaticSlots(slots) {
	let lastSlots = slots[slots.length - 1];
	if (!slots.length || lastSlots.slotType !== 0) slots.push(lastSlots = {
		slotType: 0,
		slots: {}
	});
	return lastSlots.slots;
}
function registerSlot(slots, name, block) {
	if (!name || name.isStatic) {
		const staticSlots = ensureStaticSlots(slots);
		staticSlots[name ? name.content : "default"] = block;
	} else slots.push({
		slotType: 1,
		name,
		fn: block
	});
}
function registerDynamicSlot(allSlots, dynamic) {
	allSlots.push(dynamic);
}
function hasStaticSlot(slots, name) {
	return slots.some((slot) => {
		if (slot.slotType === 0) return !!slot.slots[name];
	});
}
function createSlotBlock(slotNode, dir, context) {
	const block = newBlock(slotNode);
	block.props = dir && dir.exp;
	return [block, context.enterBlock(block)];
}
function isNonWhitespaceContent(node) {
	if (node.type !== 2) return true;
	return !!node.content.trim();
}
function isSlotTemplateChild(node) {
	return node.type === 1 && isTemplateNode(node) && !!findDir(node, "slot", true);
}
//#endregion
//#region packages/compiler-vapor/src/transforms/transformTransition.ts
const transformTransition = (node, context) => {
	if (node.type === 1 && node.tagType === 1) {
		if (isTransitionTag(node.tag)) return postTransformTransition(node, context.options.onError, hasMultipleChildren);
	}
};
function hasMultipleChildren(node) {
	const children = node.children = node.children.filter((c) => c.type !== 3 && !(c.type === 2 && !c.content.trim()));
	const first = children[0];
	if (children.length === 1 && first.type === 1) {
		if (findDir(first, "for")) return true;
		if (isTemplateNode(first)) return hasMultipleChildren(first);
	}
	const hasElse = (node) => findDir(node, "else-if") || findDir(node, "else", true);
	if (children.length > 0 && children.every((c, index) => c.type === 1 && (!isTemplateNode(c) || !hasMultipleChildren(c)) && !findDir(c, "for") && (index === 0 ? findDir(c, "if") : hasElse(c)))) return false;
	return children.length !== 1;
}
//#endregion
//#region packages/compiler-vapor/src/compile.ts
function compile$1(source, options = {}) {
	const resolvedOptions = extend({}, options);
	const ast = isString$1(source) ? parse$5(source, resolvedOptions) : source;
	const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
	if (options.isTS) {
		const { expressionPlugins } = options;
		if (!expressionPlugins || !expressionPlugins.includes("typescript")) resolvedOptions.expressionPlugins = [...expressionPlugins || [], "typescript"];
	}
	return generate(transform(ast, extend({}, resolvedOptions, {
		nodeTransforms: [
			...nodeTransforms,
			...[transformTransition],
			...options.nodeTransforms || []
		],
		directiveTransforms: extend({}, directiveTransforms, options.directiveTransforms || {})
	})), resolvedOptions);
}
function getBaseTransformPreset() {
	return [[
		transformVOnce,
		transformVIf,
		transformVFor,
		transformKey,
		transformSlotOutlet,
		transformTemplateRef,
		transformElement,
		transformText,
		transformVSlot,
		transformComment,
		transformChildren
	], {
		bind: transformVBind,
		on: transformVOn,
		html: transformVHtml,
		text: transformVText,
		show: transformVShow,
		model: transformVModel
	}];
}
//#endregion
//#region packages/compiler-vapor/src/errors.ts
function createVaporCompilerError(code, loc) {
	return createCompilerError(code, loc, VaporErrorMessages);
}
const VaporErrorCodes = {
	"X_V_PLACEHOLDER": 100,
	"100": "X_V_PLACEHOLDER",
	"__EXTEND_POINT__": 101,
	"101": "__EXTEND_POINT__"
};
const VaporErrorMessages = {
	[100]: `[placeholder]`,
	[101]: ``
};
//#endregion
//#region packages/compiler-vapor/src/index.ts
var src_exports$1 = /* @__PURE__ */ __exportAll({
	CodegenContext: () => CodegenContext,
	DynamicFlag: () => DynamicFlag,
	IRDynamicPropsKind: () => IRDynamicPropsKind,
	IRNodeTypes: () => IRNodeTypes,
	IRSlotType: () => IRSlotType,
	TemplateRegistry: () => TemplateRegistry,
	VaporErrorCodes: () => VaporErrorCodes,
	VaporErrorMessages: () => VaporErrorMessages,
	buildCodeFragment: () => buildCodeFragment,
	codeFragmentToString: () => codeFragmentToString,
	compile: () => compile$1,
	createStructuralDirectiveTransform: () => createStructuralDirectiveTransform,
	createVaporCompilerError: () => createVaporCompilerError,
	genCall: () => genCall,
	genMulti: () => genMulti,
	generate: () => generate,
	isBlockOperation: () => isBlockOperation,
	parse: () => parse$5,
	transform: () => transform,
	transformChildren: () => transformChildren,
	transformComment: () => transformComment,
	transformElement: () => transformElement,
	transformKey: () => transformKey,
	transformSlotOutlet: () => transformSlotOutlet,
	transformTemplateRef: () => transformTemplateRef,
	transformText: () => transformText,
	transformVBind: () => transformVBind,
	transformVFor: () => transformVFor,
	transformVHtml: () => transformVHtml,
	transformVIf: () => transformVIf,
	transformVModel: () => transformVModel,
	transformVOn: () => transformVOn,
	transformVOnce: () => transformVOnce,
	transformVShow: () => transformVShow,
	transformVSlot: () => transformVSlot,
	transformVText: () => transformVText,
	wrapTemplate: () => wrapTemplate
});
//#endregion
//#region packages/compiler-ssr/src/runtimeHelpers.ts
const SSR_INTERPOLATE = Symbol(`ssrInterpolate`);
const SSR_RENDER_VNODE = Symbol(`ssrRenderVNode`);
const SSR_RENDER_COMPONENT = Symbol(`ssrRenderComponent`);
const SSR_RENDER_SLOT = Symbol(`ssrRenderSlot`);
const SSR_RENDER_SLOT_INNER = Symbol(`ssrRenderSlotInner`);
const SSR_RENDER_CLASS = Symbol(`ssrRenderClass`);
const SSR_RENDER_STYLE = Symbol(`ssrRenderStyle`);
const SSR_RENDER_ATTRS = Symbol(`ssrRenderAttrs`);
const SSR_RENDER_ATTR = Symbol(`ssrRenderAttr`);
const SSR_RENDER_DYNAMIC_ATTR = Symbol(`ssrRenderDynamicAttr`);
const SSR_RENDER_LIST = Symbol(`ssrRenderList`);
const SSR_INCLUDE_BOOLEAN_ATTR = Symbol(`ssrIncludeBooleanAttr`);
const SSR_LOOSE_EQUAL = Symbol(`ssrLooseEqual`);
const SSR_LOOSE_CONTAIN = Symbol(`ssrLooseContain`);
const SSR_RENDER_DYNAMIC_MODEL = Symbol(`ssrRenderDynamicModel`);
const SSR_GET_DYNAMIC_MODEL_PROPS = Symbol(`ssrGetDynamicModelProps`);
const SSR_RENDER_TELEPORT = Symbol(`ssrRenderTeleport`);
const SSR_RENDER_SUSPENSE = Symbol(`ssrRenderSuspense`);
const SSR_GET_DIRECTIVE_PROPS = Symbol(`ssrGetDirectiveProps`);
const ssrHelpers = {
	[SSR_INTERPOLATE]: `ssrInterpolate`,
	[SSR_RENDER_VNODE]: `ssrRenderVNode`,
	[SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
	[SSR_RENDER_SLOT]: `ssrRenderSlot`,
	[SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
	[SSR_RENDER_CLASS]: `ssrRenderClass`,
	[SSR_RENDER_STYLE]: `ssrRenderStyle`,
	[SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
	[SSR_RENDER_ATTR]: `ssrRenderAttr`,
	[SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
	[SSR_RENDER_LIST]: `ssrRenderList`,
	[SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
	[SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
	[SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
	[SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
	[SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
	[SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
	[SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
	[SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
};
registerRuntimeHelpers(ssrHelpers);
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrVIf.ts
const ssrTransformIf = createStructuralDirectiveTransform$1(/^(?:if|else|else-if)$/, processIf$1);
function ssrProcessIf(node, context, disableNestedFragments = false, disableComment = false) {
	const [rootBranch] = node.branches;
	const ifStatement = createIfStatement(rootBranch.condition, processIfBranch(rootBranch, context, disableNestedFragments));
	context.pushStatement(ifStatement);
	let currentIf = ifStatement;
	for (let i = 1; i < node.branches.length; i++) {
		const branch = node.branches[i];
		const branchBlockStatement = processIfBranch(branch, context, disableNestedFragments);
		if (branch.condition) currentIf = currentIf.alternate = createIfStatement(branch.condition, branchBlockStatement);
		else currentIf.alternate = branchBlockStatement;
	}
	if (!currentIf.alternate && (!disableComment || context.options.vapor)) currentIf.alternate = createBlockStatement([createCallExpression(`_push`, ["`<!---->`"])]);
}
function processIfBranch(branch, context, disableNestedFragments = false) {
	const { children } = branch;
	return processChildrenAsStatement(branch, context, !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && !(children.length === 1 && children[0].type === 11));
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrVFor.ts
const ssrTransformFor = createStructuralDirectiveTransform$1("for", processFor$1);
function ssrProcessFor(node, context, disableNestedFragments = false) {
	const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
	const renderLoop = createFunctionExpression(createForLoopParams(node.parseResult));
	renderLoop.body = processChildrenAsStatement(node, context, needFragmentWrapper);
	if (!disableNestedFragments) context.pushStringPart(`<!--[-->`);
	context.pushStatement(createCallExpression(context.helper(SSR_RENDER_LIST), [node.source, renderLoop]));
	if (!disableNestedFragments) context.pushStringPart(`<!--]-->`);
}
//#endregion
//#region packages/compiler-ssr/src/errors.ts
function createSSRCompilerError(code, loc) {
	return createCompilerError(code, loc, SSRErrorMessages);
}
const SSRErrorMessages = {
	[65]: `Unsafe attribute name for SSR.`,
	[66]: `Missing the 'to' prop on teleport element.`,
	[67]: `Invalid AST node during SSR transform.`
};
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformTeleport.ts
function ssrProcessTeleport(node, context) {
	const targetProp = findProp$1(node, "to");
	if (!targetProp) {
		context.onError(createSSRCompilerError(66, node.loc));
		return;
	}
	let target;
	if (targetProp.type === 6) target = targetProp.value && createSimpleExpression(targetProp.value.content, true);
	else target = targetProp.exp;
	if (!target) {
		context.onError(createSSRCompilerError(66, targetProp.loc));
		return;
	}
	const disabledProp = findProp$1(node, "disabled", false, true);
	const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
	const contentRenderFn = createFunctionExpression([`_push`], void 0, true, false, node.loc);
	contentRenderFn.body = processChildrenAsStatement(node, context);
	context.pushStatement(createCallExpression(context.helper(SSR_RENDER_TELEPORT), [
		`_push`,
		contentRenderFn,
		target,
		disabled,
		`_parent`
	]));
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformSuspense.ts
const wipMap$3 = /* @__PURE__ */ new WeakMap();
function ssrTransformSuspense(node, context) {
	return () => {
		if (node.children.length) {
			const wipEntry = {
				slotsExp: null,
				wipSlots: []
			};
			wipMap$3.set(node, wipEntry);
			wipEntry.slotsExp = buildSlots(node, context, (_props, _vForExp, children, loc) => {
				const fn = createFunctionExpression([], void 0, true, false, loc);
				wipEntry.wipSlots.push({
					fn,
					children
				});
				return fn;
			}).slots;
		}
	};
}
function ssrProcessSuspense(node, context) {
	const wipEntry = wipMap$3.get(node);
	if (!wipEntry) return;
	const { slotsExp, wipSlots } = wipEntry;
	for (let i = 0; i < wipSlots.length; i++) {
		const slot = wipSlots[i];
		slot.fn.body = processChildrenAsStatement(slot, context);
	}
	context.pushStatement(createCallExpression(context.helper(SSR_RENDER_SUSPENSE), [`_push`, slotsExp]));
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformElement.ts
const rawChildrenMap = /* @__PURE__ */ new WeakMap();
const ssrTransformElement = (node, context) => {
	if (node.type !== 1 || node.tagType !== 0) return;
	return function ssrPostTransformElement() {
		const openTag = [`<${node.tag}`];
		const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
		const hasDynamicVBind = hasDynamicKeyVBind(node);
		const hasCustomDir = node.props.some((p) => p.type === 7 && !isBuiltInDirective(p.name));
		const vShowPropIndex = node.props.findIndex((i) => i.type === 7 && i.name === "show");
		if (vShowPropIndex !== -1) {
			const vShowProp = node.props[vShowPropIndex];
			node.props.splice(vShowPropIndex, 1);
			node.props.push(vShowProp);
		}
		const needMergeProps = hasDynamicVBind || hasCustomDir;
		if (needMergeProps) {
			const { props, directives } = buildProps$1(node, context, node.props, false, false, true);
			if (props || directives.length) {
				const mergedProps = buildSSRProps(props, directives, context);
				const propsExp = createCallExpression(context.helper(SSR_RENDER_ATTRS), [mergedProps]);
				if (node.tag === "textarea") {
					const existingText = node.children[0];
					if (!hasContentOverrideDirective(node) && (!existingText || existingText.type !== 5)) {
						const tempId = `_temp${context.temps++}`;
						propsExp.arguments = [createAssignmentExpression(createSimpleExpression(tempId, false), mergedProps)];
						rawChildrenMap.set(node, createCallExpression(context.helper(SSR_INTERPOLATE), [createConditionalExpression(createSimpleExpression(`"value" in ${tempId}`, false), createSimpleExpression(`${tempId}.value`, false), createSimpleExpression(existingText ? existingText.content : ``, true), false)]));
					}
				} else if (node.tag === "input") {
					const vModel = findVModel(node);
					if (vModel) {
						const tempExp = createSimpleExpression(`_temp${context.temps++}`, false);
						propsExp.arguments = [createSequenceExpression([createAssignmentExpression(tempExp, mergedProps), createCallExpression(context.helper(MERGE_PROPS), [tempExp, createCallExpression(context.helper(SSR_GET_DYNAMIC_MODEL_PROPS), [tempExp, vModel.exp])])])];
					}
				} else if (directives.length && !node.children.length) {
					if (!hasContentOverrideDirective(node)) {
						const tempId = `_temp${context.temps++}`;
						propsExp.arguments = [createAssignmentExpression(createSimpleExpression(tempId, false), mergedProps)];
						rawChildrenMap.set(node, createConditionalExpression(createSimpleExpression(`"textContent" in ${tempId}`, false), createCallExpression(context.helper(SSR_INTERPOLATE), [createSimpleExpression(`${tempId}.textContent`, false)]), createSimpleExpression(`${tempId}.innerHTML ?? ''`, false), false));
					}
				}
				if (needTagForRuntime) propsExp.arguments.push(`"${node.tag}"`);
				openTag.push(propsExp);
			}
		}
		let dynamicClassBinding = void 0;
		let staticClassBinding = void 0;
		let dynamicStyleBinding = void 0;
		for (let i = 0; i < node.props.length; i++) {
			const prop = node.props[i];
			if (node.tag === "input" && isTrueFalseValue(prop)) continue;
			if (prop.type === 7) {
				if (prop.name === "html" && prop.exp) rawChildrenMap.set(node, createCompoundExpression([
					`(`,
					prop.exp,
					`) ?? ''`
				]));
				else if (prop.name === "text" && prop.exp) node.children = [createInterpolation(prop.exp, prop.loc)];
				else if (prop.name === "slot") context.onError(createCompilerError(40, prop.loc));
				else if (isTextareaWithValue(node, prop) && prop.exp) {
					if (!needMergeProps) node.children = [createInterpolation(prop.exp, prop.loc)];
				} else if (!needMergeProps && prop.name !== "on") {
					const directiveTransform = context.directiveTransforms[prop.name];
					if (directiveTransform) {
						const { props, ssrTagParts } = directiveTransform(prop, node, context);
						if (ssrTagParts) openTag.push(...ssrTagParts);
						for (let j = 0; j < props.length; j++) {
							const { key, value } = props[j];
							if (isStaticExp(key)) {
								let attrName = key.content;
								if (attrName === "key" || attrName === "ref") continue;
								if (attrName === "class") openTag.push(` class="`, dynamicClassBinding = createCallExpression(context.helper(SSR_RENDER_CLASS), [value]), `"`);
								else if (attrName === "style") {
									if (dynamicStyleBinding) mergeCall(dynamicStyleBinding, value);
									else openTag.push(` style="`, dynamicStyleBinding = createCallExpression(context.helper(SSR_RENDER_STYLE), [value]), `"`);
								} else {
									attrName = node.tag.indexOf("-") > 0 ? attrName : propsToAttrMap[attrName] || attrName.toLowerCase();
									if (isBooleanAttr(attrName)) openTag.push(createConditionalExpression(createCallExpression(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [value]), createSimpleExpression(" " + attrName, true), createSimpleExpression("", true), false));
									else if (attrName === "hidden") openTag.push(createCallExpression(context.helper(SSR_RENDER_DYNAMIC_ATTR), [key, value]));
									else if (isSSRSafeAttrName(attrName)) openTag.push(createCallExpression(context.helper(SSR_RENDER_ATTR), [key, value]));
									else context.onError(createSSRCompilerError(65, key.loc));
								}
							} else {
								const args = [key, value];
								if (needTagForRuntime) args.push(`"${node.tag}"`);
								openTag.push(createCallExpression(context.helper(SSR_RENDER_DYNAMIC_ATTR), args));
							}
						}
					}
				}
			} else {
				const name = prop.name;
				if (node.tag === "textarea" && name === "value" && prop.value) rawChildrenMap.set(node, escapeHtml(prop.value.content));
				else if (!needMergeProps) {
					if (name === "key" || name === "ref") continue;
					if (name === "class" && prop.value) staticClassBinding = JSON.stringify(prop.value.content);
					openTag.push(` ${prop.name}` + (prop.value ? `="${escapeHtml(prop.value.content)}"` : ``));
				}
			}
		}
		if (dynamicClassBinding && staticClassBinding) {
			mergeCall(dynamicClassBinding, staticClassBinding);
			removeStaticBinding(openTag, "class");
		}
		if (context.scopeId) openTag.push(` ${context.scopeId}`);
		node.ssrCodegenNode = createTemplateLiteral(openTag);
	};
};
function buildSSRProps(props, directives, context) {
	let mergePropsArgs = [];
	if (props) {
		if (props.type === 14) mergePropsArgs = props.arguments;
		else mergePropsArgs.push(props);
	}
	if (directives.length) for (const dir of directives) mergePropsArgs.push(createCallExpression(context.helper(SSR_GET_DIRECTIVE_PROPS), [`_ctx`, ...buildDirectiveArgs(dir, context).elements]));
	return mergePropsArgs.length > 1 ? createCallExpression(context.helper(MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
}
function isTrueFalseValue(prop) {
	if (prop.type === 7) return prop.name === "bind" && prop.arg && isStaticExp(prop.arg) && (prop.arg.content === "true-value" || prop.arg.content === "false-value");
	else return prop.name === "true-value" || prop.name === "false-value";
}
function isTextareaWithValue(node, prop) {
	return !!(node.tag === "textarea" && prop.name === "bind" && isStaticArgOf(prop.arg, "value"));
}
function mergeCall(call, arg) {
	const existing = call.arguments[0];
	if (existing.type === 17) existing.elements.push(arg);
	else call.arguments[0] = createArrayExpression([existing, arg]);
}
function removeStaticBinding(tag, binding) {
	const regExp = new RegExp(`^ ${binding}=".+"$`);
	const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
	if (i > -1) tag.splice(i, 1);
}
function findVModel(node) {
	return node.props.find((p) => p.type === 7 && p.name === "model" && p.exp);
}
function hasContentOverrideDirective(node) {
	return !!findDir$1(node, "text") || !!findDir$1(node, "html");
}
function ssrProcessElement(node, context) {
	const isVoidTag = context.options.isVoidTag || NO;
	const elementsToAdd = node.ssrCodegenNode.elements;
	for (let j = 0; j < elementsToAdd.length; j++) context.pushStringPart(elementsToAdd[j]);
	if (context.withSlotScopeId) context.pushStringPart(createSimpleExpression(`_scopeId`, false));
	context.pushStringPart(`>`);
	const rawChildren = rawChildrenMap.get(node);
	if (rawChildren) context.pushStringPart(rawChildren);
	else if (node.children.length) processChildren(node, context);
	if (!isVoidTag(node.tag)) context.pushStringPart(`</${node.tag}>`);
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformTransitionGroup.ts
const wipMap$2 = /* @__PURE__ */ new WeakMap();
function ssrTransformTransitionGroup(node, context) {
	return () => {
		const tag = findProp$1(node, "tag");
		if (tag) {
			const { props, directives } = buildProps$1(node, context, node.props.filter((p) => p !== tag), true, false, true);
			let propsExp = null;
			if (props || directives.length) propsExp = createCallExpression(context.helper(SSR_RENDER_ATTRS), [buildSSRProps(props, directives, context)]);
			wipMap$2.set(node, {
				tag,
				propsExp,
				scopeId: context.scopeId || null
			});
		}
	};
}
function ssrProcessTransitionGroup(node, context) {
	const entry = wipMap$2.get(node);
	const disableNestedFragments = !context.options.vapor;
	if (entry) {
		const { tag, propsExp, scopeId } = entry;
		if (tag.type === 7) {
			context.pushStringPart(`<`);
			context.pushStringPart(tag.exp);
			if (propsExp) context.pushStringPart(propsExp);
			if (scopeId) context.pushStringPart(` ${scopeId}`);
			context.pushStringPart(`>`);
			processChildren(
				node,
				context,
				false,
				/**
				* TransitionGroup has the special runtime behavior of flattening and
				* concatenating all children into a single fragment (in order for them to
				* be patched using the same key map) so we need to account for that here
				* by disabling nested fragment wrappers from being generated.
				*/
				disableNestedFragments,
				/**
				* TransitionGroup filters out comment children at runtime and thus
				* doesn't expect comments to be present during hydration. We need to
				* account for that by disabling the empty comment that is otherwise
				* rendered for a falsy v-if that has no v-else specified. (#6715)
				*/
				true
			);
			context.pushStringPart(`</`);
			context.pushStringPart(tag.exp);
			context.pushStringPart(`>`);
		} else {
			context.pushStringPart(`<${tag.value.content}`);
			if (propsExp) context.pushStringPart(propsExp);
			if (scopeId) context.pushStringPart(` ${scopeId}`);
			context.pushStringPart(`>`);
			processChildren(node, context, false, disableNestedFragments, true);
			context.pushStringPart(`</${tag.value.content}>`);
		}
	} else processChildren(node, context, true, disableNestedFragments, true);
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformTransition.ts
const wipMap$1 = /* @__PURE__ */ new WeakMap();
function ssrTransformTransition(node, context) {
	return () => {
		const appear = findProp$1(node, "appear", false, true);
		wipMap$1.set(node, !!appear);
	};
}
function ssrProcessTransition(node, context) {
	node.children = node.children.filter((c) => c.type !== 3);
	if (wipMap$1.get(node)) {
		context.pushStringPart(`<template>`);
		processChildren(node, context, false, true);
		context.pushStringPart(`</template>`);
	} else processChildren(node, context, false, true);
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformComponent.ts
init_objectSpread2();
const wipMap = /* @__PURE__ */ new WeakMap();
const WIP_SLOT = Symbol();
const componentTypeMap = /* @__PURE__ */ new WeakMap();
const ssrTransformComponent = (node, context) => {
	if (node.type !== 1 || node.tagType !== 1) return;
	const component = resolveComponentType(node, context, true);
	const isDynamicComponent = isObject$2(component) && component.callee === RESOLVE_DYNAMIC_COMPONENT;
	componentTypeMap.set(node, component);
	if (isSymbol(component)) {
		if (component === SUSPENSE) return ssrTransformSuspense(node, context);
		else if (component === TRANSITION_GROUP) return ssrTransformTransitionGroup(node, context);
		else if (component === TRANSITION) return ssrTransformTransition(node, context);
		return;
	}
	const vnodeBranches = [];
	const clonedNode = clone(node);
	return function ssrPostTransformComponent() {
		if (clonedNode.children.length) buildSlots(clonedNode, context, (props, vFor, children) => {
			vnodeBranches.push(createVNodeSlotBranch(props, vFor, children, context));
			return createFunctionExpression(void 0);
		});
		let propsExp = `null`;
		if (node.props.length) {
			const { props, directives } = buildProps$1(node, context, void 0, true, isDynamicComponent);
			if (props || directives.length) propsExp = buildSSRProps(props, directives, context);
		}
		const wipEntries = [];
		wipMap.set(node, wipEntries);
		const buildSSRSlotFn = (props, _vForExp, children, loc) => {
			const fn = createFunctionExpression([
				props && stringifyExpression(props) || `_`,
				`_push`,
				`_parent`,
				`_scopeId`
			], void 0, true, true, loc);
			wipEntries.push({
				type: WIP_SLOT,
				fn,
				children,
				vnodeBranch: vnodeBranches[wipEntries.length]
			});
			return fn;
		};
		const slots = node.children.length ? buildSlots(node, context, buildSSRSlotFn).slots : `null`;
		if (typeof component !== "string") node.ssrCodegenNode = createCallExpression(context.helper(SSR_RENDER_VNODE), [
			`_push`,
			createCallExpression(context.helper(CREATE_VNODE), [
				component,
				propsExp,
				slots
			]),
			`_parent`
		]);
		else node.ssrCodegenNode = createCallExpression(context.helper(SSR_RENDER_COMPONENT), [
			component,
			propsExp,
			slots,
			`_parent`
		]);
	};
};
function ssrProcessComponent(node, context, parent) {
	const component = componentTypeMap.get(node);
	if (!node.ssrCodegenNode) {
		if (component === TELEPORT) return ssrProcessTeleport(node, context);
		else if (component === SUSPENSE) return ssrProcessSuspense(node, context);
		else if (component === TRANSITION_GROUP) return ssrProcessTransitionGroup(node, context);
		else {
			if (parent.type === WIP_SLOT) context.pushStringPart(``);
			if (component === TRANSITION) return ssrProcessTransition(node, context);
			processChildren(node, context);
		}
	} else {
		const wipEntries = wipMap.get(node) || [];
		for (let i = 0; i < wipEntries.length; i++) {
			const { fn, vnodeBranch } = wipEntries[i];
			fn.body = createIfStatement(createSimpleExpression(`_push`, false), processChildrenAsStatement(wipEntries[i], context, false, true), vnodeBranch);
		}
		if (context.withSlotScopeId) node.ssrCodegenNode.arguments.push(`_scopeId`);
		if (typeof component === "string") context.pushStatement(createCallExpression(`_push`, [node.ssrCodegenNode]));
		else context.pushStatement(node.ssrCodegenNode);
	}
}
const rawOptionsMap = /* @__PURE__ */ new WeakMap();
const [baseNodeTransforms, baseDirectiveTransforms] = getBaseTransformPreset$1(true);
const vnodeNodeTransforms = [...baseNodeTransforms, ...DOMNodeTransforms];
const vnodeDirectiveTransforms = _objectSpread2(_objectSpread2({}, baseDirectiveTransforms), DOMDirectiveTransforms);
function createVNodeSlotBranch(slotProps, vFor, children, parentContext) {
	const rawOptions = rawOptionsMap.get(parentContext.root);
	const subOptions = _objectSpread2(_objectSpread2({}, rawOptions), {}, {
		nodeTransforms: [...vnodeNodeTransforms, ...rawOptions.nodeTransforms || []],
		directiveTransforms: _objectSpread2(_objectSpread2({}, vnodeDirectiveTransforms), rawOptions.directiveTransforms || {})
	});
	const wrapperProps = [];
	if (slotProps) wrapperProps.push({
		type: 7,
		name: "slot",
		exp: slotProps,
		arg: void 0,
		modifiers: [],
		loc: locStub
	});
	if (vFor) wrapperProps.push(extend({}, vFor));
	subTransform({
		type: 1,
		ns: 0,
		tag: "template",
		tagType: 3,
		props: wrapperProps,
		children,
		loc: locStub,
		codegenNode: void 0
	}, subOptions, parentContext);
	return createReturnStatement(children);
}
function subTransform(node, options, parentContext) {
	const childRoot = createRoot([node]);
	const childContext = createTransformContext(childRoot, options);
	childContext.ssr = false;
	childContext.scopes = _objectSpread2({}, parentContext.scopes);
	childContext.identifiers = _objectSpread2({}, parentContext.identifiers);
	childContext.identifierScopes = Object.create(null);
	for (const name in parentContext.identifierScopes) childContext.identifierScopes[name] = parentContext.identifierScopes[name].slice();
	childContext.imports = parentContext.imports;
	traverseNode(childRoot, childContext);
	[
		"helpers",
		"components",
		"directives"
	].forEach((key) => {
		childContext[key].forEach((value, helperKey) => {
			if (key === "helpers") {
				const parentCount = parentContext.helpers.get(helperKey);
				if (parentCount === void 0) parentContext.helpers.set(helperKey, value);
				else parentContext.helpers.set(helperKey, value + parentCount);
			} else parentContext[key].add(value);
		});
	});
}
function clone(v) {
	if (isArray$3(v)) return v.map(clone);
	else if (isPlainObject(v)) {
		const res = {};
		for (const key in v) res[key] = clone(v[key]);
		return res;
	} else return v;
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrTransformSlotOutlet.ts
const ssrTransformSlotOutlet = (node, context) => {
	if (isSlotOutlet(node)) {
		const { slotName, slotProps } = processSlotOutlet(node, context);
		const args = [
			`_ctx.$slots`,
			slotName,
			slotProps || `{}`,
			`null`,
			`_push`,
			`_parent`
		];
		if (context.scopeId && context.slotted !== false) args.push(`"${context.scopeId}-s"`);
		let method = SSR_RENDER_SLOT;
		let parent = context.parent;
		if (parent && !rawOptionsMap.get(context.root).vapor) {
			const children = parent.children;
			if (parent.type === 10) parent = context.grandParent;
			let componentType;
			if (parent.type === 1 && parent.tagType === 1 && ((componentType = resolveComponentType(parent, context, true)) === TRANSITION || componentType === TRANSITION_GROUP) && children.filter((c) => c.type === 1).length === 1) {
				method = SSR_RENDER_SLOT_INNER;
				if (!(context.scopeId && context.slotted !== false)) args.push("null");
				args.push("true");
			}
		}
		node.ssrCodegenNode = createCallExpression(context.helper(method), args);
	}
};
function ssrProcessSlotOutlet(node, context) {
	const renderCall = node.ssrCodegenNode;
	if (node.children.length) {
		const fallbackRenderFn = createFunctionExpression([]);
		fallbackRenderFn.body = processChildrenAsStatement(node, context);
		renderCall.arguments[3] = fallbackRenderFn;
	}
	if (context.withSlotScopeId) {
		const slotScopeId = renderCall.arguments[6];
		renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
	}
	context.pushStatement(node.ssrCodegenNode);
}
//#endregion
//#region packages/compiler-ssr/src/ssrCodegenTransform.ts
function ssrCodegenTransform(ast, options) {
	const context = createSSRTransformContext(ast, options);
	if (options.ssrCssVars) {
		const cssContext = createTransformContext(createRoot([]), options);
		const varsExp = processExpression(createSimpleExpression(options.ssrCssVars, false), cssContext);
		context.body.push(createCompoundExpression([
			`const _cssVars = { style: `,
			varsExp,
			`}`
		]));
		Array.from(cssContext.helpers.keys()).forEach((helper) => {
			ast.helpers.add(helper);
		});
	}
	processChildren(ast, context, ast.children.length > 1 && ast.children.some((c) => !isText$1(c)));
	ast.codegenNode = createBlockStatement(context.body);
	ast.ssrHelpers = Array.from(/* @__PURE__ */ new Set([...Array.from(ast.helpers).filter((h) => h in ssrHelpers), ...context.helpers]));
	ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
}
function createSSRTransformContext(root, options, helpers = /* @__PURE__ */ new Set(), withSlotScopeId = false) {
	const body = [];
	let currentString = null;
	return {
		root,
		options,
		body,
		helpers,
		withSlotScopeId,
		onError: options.onError || ((e) => {
			throw e;
		}),
		helper(name) {
			helpers.add(name);
			return name;
		},
		pushStringPart(part) {
			if (!currentString) {
				const currentCall = createCallExpression(`_push`);
				body.push(currentCall);
				currentString = createTemplateLiteral([]);
				currentCall.arguments.push(currentString);
			}
			const bufferedElements = currentString.elements;
			const lastItem = bufferedElements[bufferedElements.length - 1];
			if (isString$1(part) && isString$1(lastItem)) bufferedElements[bufferedElements.length - 1] += part;
			else bufferedElements.push(part);
		},
		pushStatement(statement) {
			currentString = null;
			body.push(statement);
		}
	};
}
function createChildContext(parent, withSlotScopeId = parent.withSlotScopeId) {
	return createSSRTransformContext(parent.root, parent.options, parent.helpers, withSlotScopeId);
}
function processChildren(parent, context, asFragment = false, disableNestedFragments = false, disableComment = false) {
	if (asFragment) context.pushStringPart(`<!--[-->`);
	const { children } = parent;
	for (let i = 0; i < children.length; i++) {
		const child = children[i];
		switch (child.type) {
			case 1:
				switch (child.tagType) {
					case 0:
						ssrProcessElement(child, context);
						break;
					case 1:
						ssrProcessComponent(child, context, parent);
						break;
					case 2:
						ssrProcessSlotOutlet(child, context);
						break;
					case 3: break;
					default:
						context.onError(createSSRCompilerError(67, child.loc));
						return child;
				}
				break;
			case 2:
				context.pushStringPart(escapeHtml(child.content));
				break;
			case 3:
				if (!disableComment) context.pushStringPart(`<!--${child.content}-->`);
				break;
			case 5:
				context.pushStringPart(createCallExpression(context.helper(SSR_INTERPOLATE), [child.content]));
				break;
			case 9:
				ssrProcessIf(child, context, disableNestedFragments, disableComment);
				break;
			case 11:
				ssrProcessFor(child, context, disableNestedFragments);
				break;
			case 10: break;
			case 12:
			case 8: break;
			default:
				context.onError(createSSRCompilerError(67, child.loc));
				return child;
		}
	}
	if (asFragment) context.pushStringPart(`<!--]-->`);
}
function processChildrenAsStatement(parent, parentContext, asFragment = false, withSlotScopeId = parentContext.withSlotScopeId) {
	const childContext = createChildContext(parentContext, withSlotScopeId);
	processChildren(parent, childContext, asFragment);
	return createBlockStatement(childContext.body);
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrVModel.ts
const ssrTransformModel = (dir, node, context) => {
	const model = dir.exp;
	function checkDuplicatedValue() {
		const value = findProp$1(node, "value");
		if (value) context.onError(createDOMCompilerError(61, value.loc));
	}
	const processSelectChildren = (children) => {
		children.forEach((child) => {
			if (child.type === 1) processOption(child);
			else if (child.type === 11) processSelectChildren(child.children);
			else if (child.type === 9) child.branches.forEach((b) => processSelectChildren(b.children));
		});
	};
	function processOption(plainNode) {
		if (plainNode.tag === "option") {
			if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
				const value = findValueBinding(plainNode);
				plainNode.ssrCodegenNode.elements.push(createConditionalExpression(createCallExpression(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [createConditionalExpression(createCallExpression(`Array.isArray`, [model]), createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [model, value]), createCallExpression(context.helper(SSR_LOOSE_EQUAL), [model, value]))]), createSimpleExpression(" selected", true), createSimpleExpression("", true), false));
			}
		} else if (plainNode.tag === "optgroup") processSelectChildren(plainNode.children);
	}
	if (node.tagType === 0) {
		const res = { props: [] };
		if (node.tag === "input") {
			const defaultProps = [createObjectProperty(`value`, model)];
			const type = findProp$1(node, "type");
			if (type) {
				const value = findValueBinding(node);
				if (type.type === 7) res.ssrTagParts = [createCallExpression(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
					type.exp,
					model,
					value
				])];
				else if (type.value) switch (type.value.content) {
					case "radio":
						res.props = [createObjectProperty(`checked`, createCallExpression(context.helper(SSR_LOOSE_EQUAL), [model, value]))];
						break;
					case "checkbox":
						const trueValueBinding = findProp$1(node, "true-value");
						if (trueValueBinding) {
							const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
							res.props = [createObjectProperty(`checked`, createCallExpression(context.helper(SSR_LOOSE_EQUAL), [model, trueValue]))];
						} else res.props = [createObjectProperty(`checked`, createConditionalExpression(createCallExpression(`Array.isArray`, [model]), createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [model, value]), model))];
						break;
					case "file":
						context.onError(createDOMCompilerError(60, dir.loc));
						break;
					default:
						checkDuplicatedValue();
						res.props = defaultProps;
				}
			} else if (hasDynamicKeyVBind(node)) {} else {
				checkDuplicatedValue();
				res.props = defaultProps;
			}
		} else if (node.tag === "textarea") {
			checkDuplicatedValue();
			node.children = [createInterpolation(model, model.loc)];
		} else if (node.tag === "select") processSelectChildren(node.children);
		else context.onError(createDOMCompilerError(58, dir.loc));
		return res;
	} else return transformModel$1(dir, node, context);
};
function findValueBinding(node) {
	const valueBinding = findProp$1(node, "value");
	return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : createSimpleExpression(valueBinding.value.content, true) : createSimpleExpression(`null`, false);
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrVShow.ts
const ssrTransformShow = (dir, node, context) => {
	if (!dir.exp) context.onError(createDOMCompilerError(62));
	return { props: [createObjectProperty(`style`, createConditionalExpression(dir.exp, createSimpleExpression(`null`, false), createObjectExpression([createObjectProperty(`display`, createSimpleExpression(`none`, true))]), false))] };
};
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrInjectFallthroughAttrs.ts
const ssrInjectFallthroughAttrs = (node, context) => {
	if (node.type === 0) context.identifiers._attrs = 1;
	if (node.type === 1 && node.tagType === 1 && (node.tag === "transition" || node.tag === "Transition" || node.tag === "KeepAlive" || node.tag === "keep-alive")) {
		const rootChildren = filterNonCommentChildren(context.root);
		if (rootChildren.length === 1 && rootChildren[0] === node) {
			if (hasSingleChild(node)) injectFallthroughAttrs(node.children[0]);
			return;
		}
	}
	const parent = context.parent;
	if (!parent || parent.type !== 0) return;
	if (node.type === 10 && hasSingleChild(node)) {
		if (isSingleIfBlock(parent)) injectFallthroughAttrs(node.children[0]);
	} else if (hasSingleChild(parent)) injectFallthroughAttrs(node);
};
function injectFallthroughAttrs(node) {
	if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !findDir$1(node, "for")) node.props.push({
		type: 7,
		name: "bind",
		arg: void 0,
		exp: createSimpleExpression(`_attrs`, false),
		modifiers: [],
		loc: locStub
	});
}
//#endregion
//#region packages/compiler-ssr/src/transforms/ssrInjectCssVars.ts
const ssrInjectCssVars = (node, context) => {
	if (!context.ssrCssVars) return;
	if (node.type === 0) context.identifiers._cssVars = 1;
	const parent = context.parent;
	if (!parent || parent.type !== 0) return;
	if (node.type === 10) for (const child of node.children) injectCssVars(child);
	else injectCssVars(node);
};
function injectCssVars(node) {
	if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !findDir$1(node, "for")) {
		if (node.tag === "suspense" || node.tag === "Suspense") for (const child of node.children) if (child.type === 1 && child.tagType === 3) child.children.forEach(injectCssVars);
		else injectCssVars(child);
		else node.props.push({
			type: 7,
			name: "bind",
			arg: void 0,
			exp: createSimpleExpression(`_cssVars`, false),
			modifiers: [],
			loc: locStub
		});
	}
}
//#endregion
//#region packages/compiler-ssr/src/index.ts
var src_exports = /* @__PURE__ */ __exportAll({ compile: () => compile });
init_objectSpread2();
function compile(source, options = {}) {
	options = _objectSpread2(_objectSpread2(_objectSpread2({}, options), parserOptions), {}, {
		ssr: true,
		inSSR: true,
		scopeId: options.mode === "function" ? null : options.scopeId,
		prefixIdentifiers: true,
		cacheHandlers: false,
		hoistStatic: false
	});
	const ast = typeof source === "string" ? baseParse(source, options) : source;
	rawOptionsMap.set(ast, options);
	transform$1(ast, _objectSpread2(_objectSpread2({}, options), {}, {
		hoistStatic: false,
		nodeTransforms: [
			transformVBindShorthand,
			ssrTransformIf,
			ssrTransformFor,
			trackVForSlotScopes,
			transformExpression,
			ssrTransformSlotOutlet,
			ssrInjectFallthroughAttrs,
			ssrInjectCssVars,
			ssrTransformElement,
			ssrTransformComponent,
			trackSlotScopes,
			transformStyle,
			...options.nodeTransforms || []
		],
		directiveTransforms: _objectSpread2({
			bind: transformBind,
			on: transformOn$1,
			model: ssrTransformModel,
			show: ssrTransformShow,
			cloak: noopDirectiveTransform,
			once: noopDirectiveTransform,
			memo: noopDirectiveTransform
		}, options.directiveTransforms || {})
	}));
	ssrCodegenTransform(ast, options);
	return generate$1(ast, options);
}
//#endregion
//#region \0polyfill-node.fs.js
var _polyfill_node_fs_exports = /* @__PURE__ */ __exportAll({ default: () => _polyfill_node_fs_default });
var _polyfill_node_fs_default;
var init__polyfill_node_fs = __esmMin((() => {
	_polyfill_node_fs_default = {};
}));
//#endregion
//#region packages/compiler-sfc/src/warn.ts
const hasWarned = {};
function warnOnce(msg) {
	if (!hasWarned[msg]) {
		hasWarned[msg] = true;
		warn(msg);
	}
}
function warn(msg) {
	console.warn(`\x1b[1m\x1b[33m[@vue/compiler-sfc]\x1b[0m\x1b[33m ${msg}\x1b[0m\n`);
}
//#endregion
//#region packages/compiler-sfc/src/compileTemplate.ts
init_objectSpread2();
function preprocess$1({ source, filename, preprocessOptions }, preprocessor) {
	let res = "";
	let err = null;
	preprocessor.render(source, _objectSpread2({ filename }, preprocessOptions), (_err, _res) => {
		if (_err) err = _err;
		res = _res;
	});
	if (err) throw err;
	return res;
}
function compileTemplate(options) {
	const { preprocessLang, preprocessCustomRequire } = options;
	if (preprocessLang && !preprocessCustomRequire) throw new Error("[@vue/compiler-sfc] Template preprocessing in the browser build must provide the `preprocessCustomRequire` option to return the in-browser version of the preprocessor in the shape of { render(): string }.");
	const preprocessor = preprocessLang ? preprocessCustomRequire ? preprocessCustomRequire(preprocessLang) : void 0 : false;
	if (preprocessor) try {
		return doCompileTemplate(_objectSpread2(_objectSpread2({}, options), {}, {
			source: preprocess$1(options, preprocessor),
			ast: void 0
		}));
	} catch (e) {
		return {
			code: `export default function render() {}`,
			source: options.source,
			tips: [],
			errors: [e]
		};
	}
	else if (preprocessLang) return {
		code: `export default function render() {}`,
		source: options.source,
		tips: [`Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.`],
		errors: [`Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.`]
	};
	else return doCompileTemplate(options);
}
function doCompileTemplate({ filename, id, scoped, slotted, inMap, source, ast: inAST, ssr = false, vapor = false, ssrCssVars, isProd = false, compiler, compilerOptions = {}, transformAssetUrls }) {
	const errors = [];
	const warnings = [];
	let nodeTransforms = [];
	if (isObject$2(transformAssetUrls)) {
		const assetOptions = normalizeOptions(transformAssetUrls);
		nodeTransforms = [createAssetUrlTransformWithOptions(assetOptions), createSrcsetTransformWithOptions(assetOptions)];
	} else if (transformAssetUrls !== false) nodeTransforms = [transformAssetUrl, transformSrcset];
	if (ssr && !ssrCssVars) warnOnce("compileTemplate is called with `ssr: true` but no corresponding `cssVars` option.");
	if (!id) {
		warnOnce(`compileTemplate now requires the \`id\` option.`);
		id = "";
	}
	const shortId = id.replace(/^data-v-/, "");
	const longId = `data-v-${shortId}`;
	const defaultCompiler = ssr ? src_exports : vapor ? src_exports$1 : src_exports$2;
	compiler = compiler || defaultCompiler;
	if (compiler !== defaultCompiler) inAST = void 0;
	inAST = resolveTemplateAST(inAST, {
		compiler,
		compilerOptions,
		ssr,
		onError: (e) => errors.push(e)
	});
	let { code, ast, preamble, map, helpers } = compiler.compile(inAST || source, _objectSpread2(_objectSpread2({
		mode: "module",
		prefixIdentifiers: true,
		hoistStatic: true,
		cacheHandlers: true,
		ssrCssVars: ssr && ssrCssVars && ssrCssVars.length ? genCssVarsFromList(ssrCssVars, shortId, isProd, true) : "",
		scopeId: scoped ? longId : void 0,
		slotted,
		sourceMap: true,
		vapor: ssr && vapor
	}, compilerOptions), {}, {
		bindingMetadata: vapor && !ssr && compilerOptions.bindingMetadata == null ? {} : compilerOptions.bindingMetadata,
		hmr: !isProd,
		nodeTransforms: nodeTransforms.concat(compilerOptions.nodeTransforms || []),
		filename,
		onError: (e) => errors.push(e),
		onWarn: (w) => warnings.push(w)
	}));
	if (inMap && !inAST) {
		if (map) map = mapLines(inMap, map);
		if (errors.length) patchErrors(errors, source, inMap);
	}
	const tips = warnings.map((w) => {
		let msg = w.message;
		if (w.loc) msg += `\n${generateCodeFrame((inAST === null || inAST === void 0 ? void 0 : inAST.source) || source, w.loc.start.offset, w.loc.end.offset)}`;
		return msg;
	});
	return {
		code,
		ast,
		preamble,
		multiRoot: vapor ? isMultiRoot(inAST || source, compilerOptions) : void 0,
		source,
		errors,
		tips,
		map,
		helpers
	};
}
function mapLines(oldMap, newMap) {
	if (!oldMap) return newMap;
	if (!newMap) return oldMap;
	const oldMapConsumer = new import_source_map.SourceMapConsumer(oldMap);
	const newMapConsumer = new import_source_map.SourceMapConsumer(newMap);
	const mergedMapGenerator = new import_source_map.SourceMapGenerator();
	newMapConsumer.eachMapping((m) => {
		if (m.originalLine == null) return;
		const origPosInOldMap = oldMapConsumer.originalPositionFor({
			line: m.originalLine,
			column: m.originalColumn
		});
		if (origPosInOldMap.source == null) return;
		mergedMapGenerator.addMapping({
			generated: {
				line: m.generatedLine,
				column: m.generatedColumn
			},
			original: {
				line: origPosInOldMap.line,
				column: m.originalColumn
			},
			source: origPosInOldMap.source,
			name: origPosInOldMap.name
		});
	});
	const generator = mergedMapGenerator;
	oldMapConsumer.sources.forEach((sourceFile) => {
		generator._sources.add(sourceFile);
		const sourceContent = oldMapConsumer.sourceContentFor(sourceFile);
		if (sourceContent != null) mergedMapGenerator.setSourceContent(sourceFile, sourceContent);
	});
	generator._sourceRoot = oldMap.sourceRoot;
	generator._file = oldMap.file;
	return generator.toJSON();
}
function patchErrors(errors, source, inMap) {
	const originalSource = inMap.sourcesContent[0];
	const offset = originalSource.indexOf(source);
	const lineOffset = originalSource.slice(0, offset).split(/\r?\n/).length - 1;
	errors.forEach((err) => {
		if (err.loc) {
			err.loc.start.line += lineOffset;
			err.loc.start.offset += offset;
			if (err.loc.end !== err.loc.start) {
				err.loc.end.line += lineOffset;
				err.loc.end.offset += offset;
			}
		}
	});
}
//#endregion
//#region node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.browser.js
var require_picocolors_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var x = String;
	var create = function() {
		return {
			isColorSupported: false,
			reset: x,
			bold: x,
			dim: x,
			italic: x,
			underline: x,
			inverse: x,
			hidden: x,
			strikethrough: x,
			black: x,
			red: x,
			green: x,
			yellow: x,
			blue: x,
			magenta: x,
			cyan: x,
			white: x,
			gray: x,
			bgBlack: x,
			bgRed: x,
			bgGreen: x,
			bgYellow: x,
			bgBlue: x,
			bgMagenta: x,
			bgCyan: x,
			bgWhite: x,
			blackBright: x,
			redBright: x,
			greenBright: x,
			yellowBright: x,
			blueBright: x,
			magentaBright: x,
			cyanBright: x,
			whiteBright: x,
			bgBlackBright: x,
			bgRedBright: x,
			bgGreenBright: x,
			bgYellowBright: x,
			bgBlueBright: x,
			bgMagentaBright: x,
			bgCyanBright: x,
			bgWhiteBright: x
		};
	};
	module.exports = create();
	module.exports.createColors = create;
}));
//#endregion
//#region (ignored) node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/terminal-highlight
var require_terminal_highlight = /* @__PURE__ */ __commonJSMin((() => {}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/css-syntax-error.js
var require_css_syntax_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let pico = require_picocolors_browser();
	let terminalHighlight = require_terminal_highlight();
	var CssSyntaxError = class CssSyntaxError extends Error {
		constructor(message, line, column, source, file, plugin) {
			super(message);
			this.name = "CssSyntaxError";
			this.reason = message;
			if (file) this.file = file;
			if (source) this.source = source;
			if (plugin) this.plugin = plugin;
			if (typeof line !== "undefined" && typeof column !== "undefined") {
				if (typeof line === "number") {
					this.line = line;
					this.column = column;
				} else {
					this.line = line.line;
					this.column = line.column;
					this.endLine = column.line;
					this.endColumn = column.column;
				}
			}
			this.setMessage();
			if (Error.captureStackTrace) Error.captureStackTrace(this, CssSyntaxError);
		}
		setMessage() {
			this.message = this.plugin ? this.plugin + ": " : "";
			this.message += this.file ? this.file : "<css input>";
			if (typeof this.line !== "undefined") this.message += ":" + this.line + ":" + this.column;
			this.message += ": " + this.reason;
		}
		showSourceCode(color) {
			if (!this.source) return "";
			let css = this.source;
			if (color == null) color = pico.isColorSupported;
			let aside = (text) => text;
			let mark = (text) => text;
			let highlight = (text) => text;
			if (color) {
				let { bold, gray, red } = pico.createColors(true);
				mark = (text) => bold(red(text));
				aside = (text) => gray(text);
				if (terminalHighlight) highlight = (text) => terminalHighlight(text);
			}
			let lines = css.split(/\r?\n/);
			let start = Math.max(this.line - 3, 0);
			let end = Math.min(this.line + 2, lines.length);
			let maxWidth = String(end).length;
			return lines.slice(start, end).map((line, index) => {
				let number = start + 1 + index;
				let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
				if (number === this.line) {
					if (line.length > 160) {
						let padding = 20;
						let subLineStart = Math.max(0, this.column - padding);
						let subLineEnd = Math.max(this.column + padding, this.endColumn + padding);
						let subLine = line.slice(subLineStart, subLineEnd);
						let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, Math.min(this.column - 1, 19)).replace(/[^\t]/g, " ");
						return mark(">") + aside(gutter) + highlight(subLine) + "\n " + spacing + mark("^");
					}
					let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
					return mark(">") + aside(gutter) + highlight(line) + "\n " + spacing + mark("^");
				}
				return " " + aside(gutter) + highlight(line);
			}).join("\n");
		}
		toString() {
			let code = this.showSourceCode();
			if (code) code = "\n\n" + code + "\n";
			return this.name + ": " + this.message + code;
		}
	};
	module.exports = CssSyntaxError;
	CssSyntaxError.default = CssSyntaxError;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/stringifier.js
var require_stringifier = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	const STYLE_TAG = /(<)(\/?style\b)/gi;
	const COMMENT_OPEN = /(<)(!--)/g;
	const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
	function escapeHTMLInCSS(str) {
		if (typeof str !== "string") return str;
		if (!str.includes("<")) return str;
		return str.replace(STYLE_TAG, "\\3c $2").replace(COMMENT_OPEN, "\\3c $2");
	}
	const DEFAULT_RAW = {
		after: "\n",
		beforeClose: "\n",
		beforeComment: "\n",
		beforeDecl: "\n",
		beforeOpen: " ",
		beforeRule: "\n",
		colon: ": ",
		commentLeft: " ",
		commentRight: " ",
		emptyBody: "",
		indent: "    ",
		semicolon: false
	};
	function capitalize(str) {
		return str[0].toUpperCase() + str.slice(1);
	}
	function atruleStart(str, node) {
		let name = "@" + node.name;
		let params = node.params ? str.rawValue(node, "params") : "";
		let afterName = node.raws.afterName;
		if (typeof afterName === "undefined") afterName = params ? " " : "";
		else if (afterName === "" && params && !AT_NAME_END.test(params[0])) afterName = " ";
		return name + afterName + params;
	}
	function isCustomProperty(node) {
		if (!node.prop.startsWith("--")) return false;
		let before = node.raws.before;
		return typeof before === "undefined" || !/\S$/.test(before);
	}
	function pushBody(str, stack, node) {
		let nodes = node.nodes;
		let last = nodes.length - 1;
		while (last > 0) {
			if (nodes[last].type !== "comment") break;
			last -= 1;
		}
		let semicolon = str.raw(node, "semicolon");
		let isDocument = node.type === "document";
		for (let i = nodes.length - 1; i >= 0; i--) {
			let child = nodes[i];
			let childSemicolon = last !== i || semicolon;
			if (!childSemicolon && i < nodes.length - 1 && (child.type === "atrule" && !child.nodes || child.type === "decl" && isCustomProperty(child))) childSemicolon = true;
			stack.push({
				document: isDocument,
				node: child,
				semicolon: childSemicolon
			});
		}
	}
	function pushBlock(str, stack, node, start) {
		let between = str.raw(node, "between", "beforeOpen");
		str.builder(escapeHTMLInCSS(start + between) + "{", node, "start");
		let hasNodes = node.nodes && node.nodes.length;
		let close = () => {
			let after = hasNodes ? str.raw(node, "after") : str.raw(node, "after", "emptyBody");
			if (after) str.builder(escapeHTMLInCSS(after));
			str.builder("}", node, "end");
			if (node.type === "rule" && node.raws.ownSemicolon) str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, "end");
		};
		if (hasNodes) {
			stack.push(close);
			pushBody(str, stack, node);
		} else close();
	}
	var Stringifier = class Stringifier {
		constructor(builder) {
			this.builder = builder;
		}
		atrule(node, semicolon) {
			let start = atruleStart(this, node);
			if (node.nodes) this.block(node, start);
			else {
				let end = (node.raws.between || "") + (semicolon ? ";" : "");
				this.builder(escapeHTMLInCSS(start + end), node);
			}
		}
		beforeAfter(node, detect) {
			let value;
			if (node.type === "decl") value = this.raw(node, null, "beforeDecl");
			else if (node.type === "comment") value = this.raw(node, null, "beforeComment");
			else if (detect === "before") value = this.raw(node, null, "beforeRule");
			else value = this.raw(node, null, "beforeClose");
			let buf = node.parent;
			let depth = 0;
			while (buf && buf.type !== "root") {
				depth += 1;
				buf = buf.parent;
			}
			if (value.includes("\n")) {
				let indent = this.raw(node, null, "indent");
				if (indent.length) for (let step = 0; step < depth; step++) value += indent;
			}
			return value;
		}
		block(node, start) {
			let between = this.raw(node, "between", "beforeOpen");
			this.builder(escapeHTMLInCSS(start + between) + "{", node, "start");
			let after;
			if (node.nodes && node.nodes.length) {
				this.body(node);
				after = this.raw(node, "after");
			} else after = this.raw(node, "after", "emptyBody");
			if (after) this.builder(escapeHTMLInCSS(after));
			this.builder("}", node, "end");
		}
		body(node) {
			let proto = Stringifier.prototype;
			let expandable = [
				"atrule",
				"block",
				"body",
				"rule",
				"stringify"
			].every((method) => this[method] === proto[method]);
			let stack = [];
			pushBody(this, stack, node);
			while (stack.length > 0) {
				let entry = stack.pop();
				if (typeof entry === "function") {
					entry();
					continue;
				}
				let child = entry.node;
				let before = this.raw(child, "before");
				if (before) this.builder(entry.document ? before : escapeHTMLInCSS(before));
				if (expandable && child.type === "rule") pushBlock(this, stack, child, this.rawValue(child, "selector"));
				else if (expandable && child.type === "atrule" && child.nodes) pushBlock(this, stack, child, atruleStart(this, child));
				else this.stringify(child, entry.semicolon);
			}
		}
		comment(node) {
			let left = this.raw(node, "left", "commentLeft");
			let right = this.raw(node, "right", "commentRight");
			this.builder(escapeHTMLInCSS("/*" + left + node.text + right + "*/"), node);
		}
		decl(node, semicolon) {
			let raws = node.raws;
			let between = this.raw(node, "between", "colon");
			let string = node.prop + between + this.rawValue(node, "value");
			if (node.important) string += raws.important || " !important";
			if (semicolon) string += ";";
			this.builder(escapeHTMLInCSS(string), node);
		}
		document(node) {
			this.body(node);
		}
		raw(node, own, detect) {
			let value;
			if (!detect) detect = own;
			if (own) {
				value = node.raws[own];
				if (typeof value !== "undefined") return value;
			}
			let parent = node.parent;
			if (detect === "before") {
				if (!parent || parent.type === "root" && parent.first === node) return "";
				if (parent && parent.type === "document") return "";
			}
			if (!parent) return DEFAULT_RAW[detect];
			let root = node.root();
			let cache = root.rawCache || (root.rawCache = {});
			if (typeof cache[detect] !== "undefined") return cache[detect];
			if (detect === "before" || detect === "after") return this.beforeAfter(node, detect);
			else {
				let method = "raw" + capitalize(detect);
				if (this[method]) value = this[method](root, node);
				else root.walk((i) => {
					value = i.raws[own];
					if (typeof value !== "undefined") return false;
				});
			}
			if (typeof value === "undefined") value = DEFAULT_RAW[detect];
			cache[detect] = value;
			return value;
		}
		rawBeforeClose(root) {
			let value;
			root.walk((i) => {
				if (i.nodes && i.nodes.length > 0) {
					if (typeof i.raws.after !== "undefined") {
						value = i.raws.after;
						if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
						return false;
					}
				}
			});
			if (value) value = value.replace(/\S/g, "");
			return value;
		}
		rawBeforeComment(root, node) {
			let value;
			root.walkComments((i) => {
				if (typeof i.raws.before !== "undefined") {
					value = i.raws.before;
					if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
					return false;
				}
			});
			if (typeof value === "undefined") value = this.raw(node, null, "beforeDecl");
			else if (value) value = value.replace(/\S/g, "");
			return value;
		}
		rawBeforeDecl(root, node) {
			let value;
			root.walkDecls((i) => {
				if (typeof i.raws.before !== "undefined") {
					value = i.raws.before;
					if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
					return false;
				}
			});
			if (typeof value === "undefined") value = this.raw(node, null, "beforeRule");
			else if (value) value = value.replace(/\S/g, "");
			return value;
		}
		rawBeforeOpen(root) {
			let value;
			root.walk((i) => {
				if (i.type !== "decl") {
					value = i.raws.between;
					if (typeof value !== "undefined") return false;
				}
			});
			return value;
		}
		rawBeforeRule(root) {
			let value;
			root.walk((i) => {
				if (i.nodes && (i.parent !== root || root.first !== i)) {
					if (typeof i.raws.before !== "undefined") {
						value = i.raws.before;
						if (value.includes("\n")) value = value.replace(/[^\n]+$/, "");
						return false;
					}
				}
			});
			if (value) value = value.replace(/\S/g, "");
			return value;
		}
		rawColon(root) {
			let value;
			root.walkDecls((i) => {
				if (typeof i.raws.between !== "undefined") {
					value = i.raws.between.replace(/[^\s:]/g, "");
					return false;
				}
			});
			return value;
		}
		rawEmptyBody(root) {
			let value;
			root.walk((i) => {
				if (i.nodes && i.nodes.length === 0) {
					value = i.raws.after;
					if (typeof value !== "undefined") return false;
				}
			});
			return value;
		}
		rawIndent(root) {
			if (root.raws.indent) return root.raws.indent;
			let value;
			root.walk((i) => {
				let p = i.parent;
				if (p && p !== root && p.parent && p.parent === root) {
					if (typeof i.raws.before !== "undefined") {
						let parts = i.raws.before.split("\n");
						value = parts[parts.length - 1];
						value = value.replace(/\S/g, "");
						return false;
					}
				}
			});
			return value;
		}
		rawSemicolon(root) {
			let value;
			root.walk((i) => {
				if (i.nodes && i.nodes.length && i.last.type === "decl") {
					value = i.raws.semicolon;
					if (typeof value !== "undefined") return false;
				}
			});
			return value;
		}
		rawValue(node, prop) {
			let value = node[prop];
			let raw = node.raws[prop];
			if (raw && raw.value === value) return raw.raw;
			return value;
		}
		root(node) {
			if (node.source && node.source.input.hasBOM) this.builder("", node, "start");
			this.body(node);
			if (node.raws.after) {
				let after = node.raws.after;
				let isDocument = node.parent && node.parent.type === "document";
				this.builder(isDocument ? after : escapeHTMLInCSS(after));
			}
		}
		rule(node) {
			this.block(node, this.rawValue(node, "selector"));
			if (node.raws.ownSemicolon) this.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, "end");
		}
		stringify(node, semicolon) {
			/* c8 ignore start */
			if (!this[node.type]) throw new Error("Unknown AST node type " + node.type + ". Maybe you need to change PostCSS stringifier.");
			/* c8 ignore stop */
			this[node.type](node, semicolon);
		}
	};
	module.exports = Stringifier;
	Stringifier.default = Stringifier;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/stringify.js
var require_stringify = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Stringifier = require_stringifier();
	function stringify(node, builder) {
		new Stringifier(builder).stringify(node);
	}
	module.exports = stringify;
	stringify.default = stringify;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/symbols.js
var require_symbols = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	module.exports.isClean = Symbol("isClean");
	module.exports.my = Symbol("my");
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/node.js
var require_node$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let CssSyntaxError = require_css_syntax_error();
	let Stringifier = require_stringifier();
	let stringify = require_stringify();
	let { isClean, my } = require_symbols();
	function cloneNode(obj, parent) {
		let cloned = new obj.constructor();
		let stack = [[
			obj,
			cloned,
			parent
		]];
		while (stack.length > 0) {
			let [source, target, targetParent] = stack.pop();
			for (let i in source) {
				if (!Object.prototype.hasOwnProperty.call(source, i))
 /* c8 ignore next 2 */
				continue;
				if (i === "proxyCache") continue;
				let value = source[i];
				let type = typeof value;
				if (i === "parent" && type === "object") {
					if (targetParent) target[i] = targetParent;
				} else if (i === "source") target[i] = value;
				else if (Array.isArray(value)) {
					let children = [];
					target[i] = children;
					for (let j of value) {
						let childClone = new j.constructor();
						children.push(childClone);
						stack.push([
							j,
							childClone,
							target
						]);
					}
				} else {
					if (type === "object" && value !== null) {
						let valueClone = new value.constructor();
						stack.push([
							value,
							valueClone,
							void 0
						]);
						value = valueClone;
					}
					target[i] = value;
				}
			}
		}
		return cloned;
	}
	function sourceOffset(inputCSS, position) {
		if (position && typeof position.offset !== "undefined") return position.offset;
		let column = 1;
		let line = 1;
		let offset = 0;
		for (let i = 0; i < inputCSS.length; i++) {
			if (line === position.line && column === position.column) {
				offset = i;
				break;
			}
			if (inputCSS[i] === "\n") {
				column = 1;
				line += 1;
			} else column += 1;
		}
		return offset;
	}
	var Node = class Node {
		get proxyOf() {
			return this;
		}
		constructor(defaults = {}) {
			this.raws = {};
			this[isClean] = false;
			this[my] = true;
			for (let name of Object.keys(defaults)) {
				if (name === "__proto__") continue;
				if (name === "nodes") {
					this.nodes = [];
					for (let node of defaults[name]) if (typeof node.clone === "function" && node.parent) this.append(node.clone());
					else this.append(node);
				} else this[name] = defaults[name];
			}
		}
		addToError(error) {
			error.postcssNode = this;
			if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
				let s = this.source;
				error.stack = error.stack.replace(/\n\s{4}at /, `$&${s.input.from}:${s.start.line}:${s.start.column}$&`);
			}
			return error;
		}
		after(add) {
			this.parent.insertAfter(this, add);
			return this;
		}
		assign(overrides = {}) {
			for (let name in overrides) this[name] = overrides[name];
			return this;
		}
		before(add) {
			this.parent.insertBefore(this, add);
			return this;
		}
		cleanRaws(keepBetween) {
			delete this.raws.before;
			delete this.raws.after;
			if (!keepBetween) delete this.raws.between;
		}
		clone(overrides = {}) {
			let cloned = cloneNode(this);
			for (let name in overrides) cloned[name] = overrides[name];
			return cloned;
		}
		cloneAfter(overrides = {}) {
			let cloned = this.clone(overrides);
			this.parent.insertAfter(this, cloned);
			return cloned;
		}
		cloneBefore(overrides = {}) {
			let cloned = this.clone(overrides);
			this.parent.insertBefore(this, cloned);
			return cloned;
		}
		error(message, opts = {}) {
			if (this.source) {
				let { end, start } = this.rangeBy(opts);
				return this.source.input.error(message, {
					column: start.column,
					line: start.line
				}, {
					column: end.column,
					line: end.line
				}, opts);
			}
			return new CssSyntaxError(message);
		}
		getProxyProcessor() {
			return {
				get(node, prop) {
					if (prop === "proxyOf") return node;
					else if (prop === "root") return () => node.root().toProxy();
					else return node[prop];
				},
				set(node, prop, value) {
					if (node[prop] === value) return true;
					node[prop] = value;
					if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || 
					/* c8 ignore next */
					prop === "text") node.markDirty();
					return true;
				}
			};
		}
		/* c8 ignore next 3 */
		markClean() {
			this[isClean] = true;
		}
		markDirty() {
			if (this[isClean]) {
				this[isClean] = false;
				let next = this;
				while (next = next.parent) next[isClean] = false;
			}
		}
		next() {
			if (!this.parent) return void 0;
			let index = this.parent.index(this);
			return this.parent.nodes[index + 1];
		}
		positionBy(opts = {}) {
			let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
			let pos = {
				column: this.source.start.column,
				line: this.source.start.line,
				offset: sourceOffset(inputString, this.source.start)
			};
			if (opts.index) pos = this.positionInside(opts.index);
			else if (opts.word) {
				let index = inputString.slice(sourceOffset(inputString, this.source.start), sourceOffset(inputString, this.source.end)).indexOf(opts.word);
				if (index !== -1) pos = this.positionInside(index);
			}
			return pos;
		}
		positionInside(index) {
			let column = this.source.start.column;
			let line = this.source.start.line;
			let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
			let offset = sourceOffset(inputString, this.source.start);
			let end = offset + index;
			for (let i = offset; i < end; i++) if (inputString[i] === "\n") {
				column = 1;
				line += 1;
			} else column += 1;
			return {
				column,
				line,
				offset: end
			};
		}
		prev() {
			if (!this.parent) return void 0;
			let index = this.parent.index(this);
			return this.parent.nodes[index - 1];
		}
		rangeBy(opts = {}) {
			let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
			let start = {
				column: this.source.start.column,
				line: this.source.start.line,
				offset: sourceOffset(inputString, this.source.start)
			};
			let end = this.source.end ? {
				column: this.source.end.column + 1,
				line: this.source.end.line,
				offset: typeof this.source.end.offset === "number" ? this.source.end.offset : sourceOffset(inputString, this.source.end) + 1
			} : {
				column: start.column + 1,
				line: start.line,
				offset: start.offset + 1
			};
			if (opts.word) {
				let index = inputString.slice(sourceOffset(inputString, this.source.start), sourceOffset(inputString, this.source.end)).indexOf(opts.word);
				if (index !== -1) {
					start = this.positionInside(index);
					end = this.positionInside(index + opts.word.length);
				}
			} else {
				if (opts.start) start = {
					column: opts.start.column,
					line: opts.start.line,
					offset: sourceOffset(inputString, opts.start)
				};
				else if (typeof opts.index === "number") start = this.positionInside(opts.index);
				if (opts.end) end = {
					column: opts.end.column,
					line: opts.end.line,
					offset: sourceOffset(inputString, opts.end)
				};
				else if (typeof opts.endIndex === "number") end = this.positionInside(opts.endIndex);
				else if (typeof opts.index === "number") end = this.positionInside(opts.index + 1);
			}
			if (end.line < start.line || end.line === start.line && end.column <= start.column) end = {
				column: start.column + 1,
				line: start.line,
				offset: start.offset + 1
			};
			return {
				end,
				start
			};
		}
		raw(prop, defaultType) {
			return new Stringifier().raw(this, prop, defaultType);
		}
		remove() {
			if (this.parent) this.parent.removeChild(this);
			this.parent = void 0;
			return this;
		}
		replaceWith(...nodes) {
			if (this.parent) {
				let bookmark = this;
				let foundSelf = false;
				for (let node of nodes) if (node === this) foundSelf = true;
				else if (foundSelf) {
					this.parent.insertAfter(bookmark, node);
					bookmark = node;
				} else this.parent.insertBefore(bookmark, node);
				if (!foundSelf) this.remove();
			}
			return this;
		}
		root() {
			let result = this;
			while (result.parent && result.parent.type !== "document") result = result.parent;
			return result;
		}
		toJSON(_, inputs) {
			let emitInputs = inputs == null;
			inputs = inputs || /* @__PURE__ */ new Map();
			let holderOfRoot = [];
			let queue = [[
				this,
				holderOfRoot,
				0
			]];
			for (let step = 0; step < queue.length; step++) {
				let [node, holder, key] = queue[step];
				let fixed = {};
				holder[key] = fixed;
				for (let name in node) {
					if (!Object.prototype.hasOwnProperty.call(node, name))
 /* c8 ignore next 2 */
					continue;
					if (name === "parent" || name === "proxyCache") continue;
					let value = node[name];
					if (Array.isArray(value)) {
						let fixedArray = [];
						fixed[name] = fixedArray;
						for (let i = 0; i < value.length; i++) {
							let item = value[i];
							if (typeof item === "object" && item.toJSON) {
								if (item.toJSON === Node.prototype.toJSON) queue.push([
									item,
									fixedArray,
									i
								]);
								else fixedArray[i] = item.toJSON(null, inputs);
							} else fixedArray[i] = item;
						}
					} else if (typeof value === "object" && value.toJSON) {
						if (value.toJSON === Node.prototype.toJSON) queue.push([
							value,
							fixed,
							name
						]);
						else fixed[name] = value.toJSON(null, inputs);
					} else if (name === "source") {
						if (value == null) continue;
						let inputId = inputs.get(value.input);
						if (inputId == null) {
							inputId = inputs.size;
							inputs.set(value.input, inputId);
						}
						fixed[name] = {
							end: value.end,
							inputId,
							start: value.start
						};
					} else fixed[name] = value;
				}
			}
			let fixed = holderOfRoot[0];
			if (emitInputs) fixed.inputs = [...inputs.keys()].map((input) => input.toJSON());
			return fixed;
		}
		toProxy() {
			if (!this.proxyCache) this.proxyCache = new Proxy(this, this.getProxyProcessor());
			return this.proxyCache;
		}
		toString(stringifier = stringify) {
			if (stringifier.stringify) stringifier = stringifier.stringify;
			let result = "";
			stringifier(this, (i) => {
				result += i;
			});
			return result;
		}
		warn(result, text, opts = {}) {
			let data = { node: this };
			for (let i in opts) data[i] = opts[i];
			return result.warn(text, data);
		}
	};
	module.exports = Node;
	Node.default = Node;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/comment.js
var require_comment$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Node = require_node$1();
	var Comment = class extends Node {
		constructor(defaults) {
			super(defaults);
			this.type = "comment";
		}
	};
	module.exports = Comment;
	Comment.default = Comment;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/declaration.js
var require_declaration = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init_objectSpread2();
	let Node = require_node$1();
	var Declaration = class extends Node {
		get variable() {
			return this.prop.startsWith("--") || this.prop[0] === "$";
		}
		constructor(defaults) {
			if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") defaults = _objectSpread2(_objectSpread2({}, defaults), {}, { value: String(defaults.value) });
			super(defaults);
			this.type = "decl";
		}
	};
	module.exports = Declaration;
	Declaration.default = Declaration;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/container.js
var require_container$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Comment = require_comment$1();
	let Declaration = require_declaration();
	let Node = require_node$1();
	let { isClean, my } = require_symbols();
	let AtRule;
	let parse;
	let Root;
	let Rule;
	function cleanSource(nodes) {
		let stack = nodes.slice();
		while (stack.length > 0) {
			let node = stack.pop();
			delete node.source;
			if (node.nodes) {
				node.nodes = node.nodes.slice();
				for (let i of node.nodes) stack.push(i);
			}
		}
		return nodes.slice();
	}
	function markTreeDirty(node) {
		let stack = [node];
		while (stack.length > 0) {
			let next = stack.pop();
			next[isClean] = false;
			if (next.proxyOf.nodes) for (let i of next.proxyOf.nodes) stack.push(i);
		}
	}
	var Container = class Container extends Node {
		get first() {
			if (!this.proxyOf.nodes) return void 0;
			return this.proxyOf.nodes[0];
		}
		get last() {
			if (!this.proxyOf.nodes) return void 0;
			return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
		}
		append(...children) {
			for (let child of children) {
				let nodes = this.normalize(child, this.last);
				for (let node of nodes) this.proxyOf.nodes.push(node);
			}
			this.markDirty();
			return this;
		}
		cleanRaws(keepBetween) {
			let stack = [this];
			while (stack.length > 0) {
				let node = stack.pop();
				if (node !== this && node.cleanRaws !== Container.prototype.cleanRaws) {
					node.cleanRaws(keepBetween);
					continue;
				}
				Node.prototype.cleanRaws.call(node, keepBetween);
				if (node.nodes) for (let child of node.nodes) stack.push(child);
			}
		}
		each(callback) {
			if (!this.proxyOf.nodes) return void 0;
			let iterator = this.getIterator();
			let index, result;
			while (this.indexes[iterator] < this.proxyOf.nodes.length) {
				index = this.indexes[iterator];
				result = callback(this.proxyOf.nodes[index], index);
				if (result === false) break;
				this.indexes[iterator] += 1;
			}
			delete this.indexes[iterator];
			return result;
		}
		every(condition) {
			return this.nodes.every(condition);
		}
		getIterator() {
			if (!this.lastEach) this.lastEach = 0;
			if (!this.indexes) this.indexes = {};
			this.lastEach += 1;
			let iterator = this.lastEach;
			this.indexes[iterator] = 0;
			return iterator;
		}
		getProxyProcessor() {
			return {
				get(node, prop) {
					if (prop === "proxyOf") return node;
					else if (!node[prop]) return node[prop];
					else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) return (...args) => {
						return node[prop](...args.map((i) => {
							if (typeof i === "function") return (child, index) => i(child.toProxy(), index);
							else return i;
						}));
					};
					else if (prop === "every" || prop === "some") return (cb) => {
						return node[prop]((child, ...other) => cb(child.toProxy(), ...other));
					};
					else if (prop === "root") return () => node.root().toProxy();
					else if (prop === "nodes") return node.nodes.map((i) => i.toProxy());
					else if (prop === "first" || prop === "last") return node[prop].toProxy();
					else return node[prop];
				},
				set(node, prop, value) {
					if (node[prop] === value) return true;
					node[prop] = value;
					if (prop === "name" || prop === "params" || prop === "selector") node.markDirty();
					return true;
				}
			};
		}
		index(child) {
			if (typeof child === "number") return child;
			if (child.proxyOf) child = child.proxyOf;
			return this.proxyOf.nodes.indexOf(child);
		}
		insertAfter(exist, add) {
			let existIndex = this.index(exist);
			let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
			existIndex = this.index(exist);
			for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node);
			let index;
			for (let id in this.indexes) {
				index = this.indexes[id];
				if (existIndex < index) this.indexes[id] = index + nodes.length;
			}
			this.markDirty();
			return this;
		}
		insertBefore(exist, add) {
			let existIndex = this.index(exist);
			let type = existIndex === 0 ? "prepend" : false;
			let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
			existIndex = this.index(exist);
			for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
			let index;
			for (let id in this.indexes) {
				index = this.indexes[id];
				if (existIndex <= index) this.indexes[id] = index + nodes.length;
			}
			this.markDirty();
			return this;
		}
		normalize(nodes, sample) {
			if (typeof nodes === "string") nodes = cleanSource(parse(nodes).nodes);
			else if (typeof nodes === "undefined") nodes = [];
			else if (Array.isArray(nodes)) {
				nodes = nodes.slice(0);
				for (let i of nodes) if (i.parent) i.parent.removeChild(i, "ignore");
			} else if (nodes.type === "root" && this.type !== "document") {
				nodes = nodes.nodes.slice(0);
				for (let i of nodes) if (i.parent) i.parent.removeChild(i, "ignore");
			} else if (nodes.type) nodes = [nodes];
			else if (nodes.prop) {
				if (typeof nodes.value === "undefined") throw new Error("Value field is missed in node creation");
				else if (typeof nodes.value !== "string") nodes.value = String(nodes.value);
				nodes = [new Declaration(nodes)];
			} else if (nodes.selector || nodes.selectors) nodes = [new Rule(nodes)];
			else if (nodes.name) nodes = [new AtRule(nodes)];
			else if (nodes.text) nodes = [new Comment(nodes)];
			else throw new Error("Unknown node type in node creation");
			return nodes.map((i) => {
				/* c8 ignore next */
				if (!i[my]) Container.rebuild(i);
				i = i.proxyOf;
				if (i.parent) i.parent.removeChild(i);
				if (i[isClean]) markTreeDirty(i);
				if (!i.raws) i.raws = {};
				if (typeof i.raws.before === "undefined") {
					if (sample && typeof sample.raws.before !== "undefined") i.raws.before = sample.raws.before.replace(/\S/g, "");
				}
				i.parent = this.proxyOf;
				return i;
			});
		}
		prepend(...children) {
			children = children.reverse();
			for (let child of children) {
				let nodes = this.normalize(child, this.first, "prepend").reverse();
				for (let node of nodes) this.proxyOf.nodes.unshift(node);
				for (let id in this.indexes) this.indexes[id] = this.indexes[id] + nodes.length;
			}
			this.markDirty();
			return this;
		}
		push(child) {
			child.parent = this;
			this.proxyOf.nodes.push(child);
			return this;
		}
		removeAll() {
			for (let node of this.proxyOf.nodes) node.parent = void 0;
			this.proxyOf.nodes = [];
			this.markDirty();
			return this;
		}
		removeChild(child) {
			child = this.index(child);
			this.proxyOf.nodes[child].parent = void 0;
			this.proxyOf.nodes.splice(child, 1);
			let index;
			for (let id in this.indexes) {
				index = this.indexes[id];
				if (index >= child) this.indexes[id] = index - 1;
			}
			this.markDirty();
			return this;
		}
		replaceValues(pattern, opts, callback) {
			if (!callback) {
				callback = opts;
				opts = {};
			}
			this.walkDecls((decl) => {
				if (opts.props && !opts.props.includes(decl.prop)) return;
				if (opts.fast && !decl.value.includes(opts.fast)) return;
				decl.value = decl.value.replace(pattern, callback);
			});
			this.markDirty();
			return this;
		}
		some(condition) {
			return this.nodes.some(condition);
		}
		walk(callback) {
			if (!this.proxyOf.nodes) return void 0;
			let stack = [{
				iterator: this.getIterator(),
				node: this.proxyOf
			}];
			while (stack.length > 0) {
				let { iterator, node } = stack[stack.length - 1];
				let index = node.indexes[iterator];
				if (index >= node.proxyOf.nodes.length) {
					delete node.indexes[iterator];
					stack.pop();
					let parent = stack[stack.length - 1];
					if (parent) parent.node.indexes[parent.iterator] += 1;
					continue;
				}
				let child = node.proxyOf.nodes[index];
				let result;
				try {
					result = callback(child, index);
				} catch (e) {
					throw child.addToError(e);
				}
				if (result === false) {
					for (let opened of stack) delete opened.node.indexes[opened.iterator];
					return false;
				}
				if (child.walk && child.proxyOf.nodes) stack.push({
					iterator: child.getIterator(),
					node: child
				});
				else node.indexes[iterator] += 1;
			}
		}
		walkAtRules(name, callback) {
			if (!callback) {
				callback = name;
				return this.walk((child, i) => {
					if (child.type === "atrule") return callback(child, i);
				});
			}
			if (name instanceof RegExp) return this.walk((child, i) => {
				if (child.type === "atrule" && name.test(child.name)) return callback(child, i);
			});
			return this.walk((child, i) => {
				if (child.type === "atrule" && child.name === name) return callback(child, i);
			});
		}
		walkComments(callback) {
			return this.walk((child, i) => {
				if (child.type === "comment") return callback(child, i);
			});
		}
		walkDecls(prop, callback) {
			if (!callback) {
				callback = prop;
				return this.walk((child, i) => {
					if (child.type === "decl") return callback(child, i);
				});
			}
			if (prop instanceof RegExp) return this.walk((child, i) => {
				if (child.type === "decl" && prop.test(child.prop)) return callback(child, i);
			});
			return this.walk((child, i) => {
				if (child.type === "decl" && child.prop === prop) return callback(child, i);
			});
		}
		walkRules(selector, callback) {
			if (!callback) {
				callback = selector;
				return this.walk((child, i) => {
					if (child.type === "rule") return callback(child, i);
				});
			}
			if (selector instanceof RegExp) return this.walk((child, i) => {
				if (child.type === "rule" && selector.test(child.selector)) return callback(child, i);
			});
			return this.walk((child, i) => {
				if (child.type === "rule" && child.selector === selector) return callback(child, i);
			});
		}
	};
	Container.registerParse = (dependant) => {
		parse = dependant;
	};
	Container.registerRule = (dependant) => {
		Rule = dependant;
	};
	Container.registerAtRule = (dependant) => {
		AtRule = dependant;
	};
	Container.registerRoot = (dependant) => {
		Root = dependant;
	};
	module.exports = Container;
	Container.default = Container;
	/* c8 ignore start */
	Container.rebuild = (node) => {
		let stack = [node];
		while (stack.length > 0) {
			let next = stack.pop();
			if (next.type === "atrule") Object.setPrototypeOf(next, AtRule.prototype);
			else if (next.type === "rule") Object.setPrototypeOf(next, Rule.prototype);
			else if (next.type === "decl") Object.setPrototypeOf(next, Declaration.prototype);
			else if (next.type === "comment") Object.setPrototypeOf(next, Comment.prototype);
			else if (next.type === "root") Object.setPrototypeOf(next, Root.prototype);
			next[my] = true;
			if (next.nodes) for (let child of next.nodes) stack.push(child);
		}
	};
}));
/* c8 ignore stop */
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/at-rule.js
var require_at_rule = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Container = require_container$1();
	var AtRule = class extends Container {
		constructor(defaults) {
			super(defaults);
			this.type = "atrule";
		}
		append(...children) {
			if (!this.proxyOf.nodes) this.nodes = [];
			return super.append(...children);
		}
		prepend(...children) {
			if (!this.proxyOf.nodes) this.nodes = [];
			return super.prepend(...children);
		}
	};
	module.exports = AtRule;
	AtRule.default = AtRule;
	Container.registerAtRule(AtRule);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/document.js
var require_document = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init_objectSpread2();
	let Container = require_container$1();
	let LazyResult;
	let Processor;
	var Document = class extends Container {
		constructor(defaults) {
			super(_objectSpread2({ type: "document" }, defaults));
			if (!this.nodes) this.nodes = [];
		}
		toResult(opts = {}) {
			return new LazyResult(new Processor(), this, opts).stringify();
		}
	};
	Document.registerLazyResult = (dependant) => {
		LazyResult = dependant;
	};
	Document.registerProcessor = (dependant) => {
		Processor = dependant;
	};
	module.exports = Document;
	Document.default = Document;
}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/objectWithoutPropertiesLoose.js
function _objectWithoutPropertiesLoose(r, e) {
	if (null == r) return {};
	var t = {};
	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
		if (e.includes(n)) continue;
		t[n] = r[n];
	}
	return t;
}
var init_objectWithoutPropertiesLoose = __esmMin((() => {}));
//#endregion
//#region \0@oxc-project+runtime@0.146.0/helpers/esm/objectWithoutProperties.js
function _objectWithoutProperties(e, t) {
	if (null == e) return {};
	var o, r, i = _objectWithoutPropertiesLoose(e, t);
	if (Object.getOwnPropertySymbols) {
		var s = Object.getOwnPropertySymbols(e);
		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
	}
	return i;
}
var init_objectWithoutProperties = __esmMin((() => {
	init_objectWithoutPropertiesLoose();
}));
//#endregion
//#region node_modules/.pnpm/nanoid@3.3.19/node_modules/nanoid/non-secure/index.cjs
var require_non_secure = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
	let customAlphabet = (alphabet, defaultSize = 21) => {
		return (size = defaultSize) => {
			let id = "";
			let i = size | 0;
			while (i-- > 0) id += alphabet[Math.random() * alphabet.length | 0];
			return id;
		};
	};
	let nanoid = (size = 21) => {
		let id = "";
		let i = size | 0;
		while (i-- > 0) id += urlAlphabet[Math.random() * 64 | 0];
		return id;
	};
	module.exports = {
		nanoid,
		customAlphabet
	};
}));
//#endregion
//#region (ignored) node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib
var require_lib = /* @__PURE__ */ __commonJSMin((() => {}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/previous-map.js
var require_previous_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init__polyfill_node_buffer();
	let { existsSync, readFileSync, realpathSync } = (init__polyfill_node_fs(), __toCommonJS(_polyfill_node_fs_exports));
	let { dirname, isAbsolute, join, relative, sep } = (init__polyfill_node_path(), __toCommonJS(_polyfill_node_path_exports));
	let { SourceMapConsumer, SourceMapGenerator } = require_lib();
	function realPath(path) {
		try {
			return realpathSync(path);
		} catch (_unused) {
			return path;
		}
	}
	function fromBase64(str) {
		if (Buffer$1) return Buffer$1.from(str, "base64").toString();
		else
 /* c8 ignore next 2 */
		return window.atob(str);
	}
	var PreviousMap = class {
		constructor(css, opts) {
			if (opts.map === false) return;
			if (opts.unsafeMap) this.unsafeMap = true;
			this.loadAnnotation(css);
			this.inline = this.startWith(this.annotation, "data:");
			let prev = opts.map ? opts.map.prev : void 0;
			let text = this.loadMap(opts.from, prev);
			if (!this.mapFile && opts.from) this.mapFile = opts.from;
			if (this.mapFile) this.root = dirname(this.mapFile);
			if (text) this.text = text;
		}
		consumer() {
			if (!this.consumerCache) this.consumerCache = new SourceMapConsumer(this.json || this.text);
			return this.consumerCache;
		}
		decodeInline(text) {
			let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
			let baseUri = /^data:application\/json;base64,/;
			let uriMatch = text.match(/^data:application\/json;charset=utf-?8,/) || text.match(/^data:application\/json,/);
			if (uriMatch) return decodeURIComponent(text.substr(uriMatch[0].length));
			let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
			if (baseUriMatch) return fromBase64(text.substr(baseUriMatch[0].length));
			let encoding = text.slice(22);
			encoding = encoding.slice(0, encoding.indexOf(","));
			throw new Error("Unsupported source map encoding " + encoding);
		}
		getAnnotationURL(sourceMapString) {
			return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
		}
		isMap(map) {
			if (typeof map !== "object") return false;
			return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
		}
		loadAnnotation(css) {
			let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
			if (!comments) return;
			let start = css.lastIndexOf(comments.pop());
			let end = css.indexOf("*/", start);
			if (start > -1 && end > -1) this.annotation = this.getAnnotationURL(css.substring(start, end));
		}
		loadFile(path, cssFile, trusted) {
			if (!trusted && !this.unsafeMap) {
				if (!/\.map$/i.test(path)) return void 0;
				if (!cssFile) return void 0;
				let rel = relative(realPath(dirname(cssFile)), realPath(path));
				if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) return;
			}
			this.root = dirname(path);
			if (existsSync(path)) {
				this.mapFile = path;
				return readFileSync(path, "utf-8").toString().trim();
			}
		}
		loadMap(file, prev) {
			if (prev === false) return false;
			if (prev) {
				if (typeof prev === "string") return prev;
				else if (typeof prev === "function") {
					let prevPath = prev(file);
					if (prevPath) {
						let map = this.loadFile(prevPath, file, true);
						if (!map) throw new Error("Unable to load previous source map: " + prevPath.toString());
						return map;
					}
				} else if (prev instanceof SourceMapConsumer) return SourceMapGenerator.fromSourceMap(prev).toString();
				else if (prev instanceof SourceMapGenerator) return prev.toString();
				else if (this.isMap(prev)) return JSON.stringify(prev);
				else throw new Error("Unsupported previous source map format: " + prev.toString());
			} else if (this.inline) return this.decodeInline(this.annotation);
			else if (this.annotation) {
				let map = this.annotation;
				if (file) map = join(dirname(file), map);
				let unknown = this.loadFile(map, file, false);
				if (unknown) try {
					/* c8 ignore next 4 */
					this.json = JSON.parse(unknown.replace(/^\)]}'[^\n]*\n/, ""));
				} catch (_unused2) {
					return;
				}
				return unknown;
			}
		}
		startWith(string, start) {
			if (!string) return false;
			return string.substr(0, start.length) === start;
		}
		withContent() {
			return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
		}
	};
	module.exports = PreviousMap;
	PreviousMap.default = PreviousMap;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/input.js
var require_input = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init_objectSpread2();
	let { nanoid } = require_non_secure();
	let { isAbsolute, resolve } = (init__polyfill_node_path(), __toCommonJS(_polyfill_node_path_exports));
	let { SourceMapConsumer, SourceMapGenerator } = require_lib();
	let { fileURLToPath, pathToFileURL } = (init__polyfill_node_url(), __toCommonJS(_polyfill_node_url_exports));
	let CssSyntaxError = require_css_syntax_error();
	let PreviousMap = require_previous_map();
	let terminalHighlight = require_terminal_highlight();
	let lineToIndexCache = Symbol("lineToIndexCache");
	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
	let pathAvailable = Boolean(resolve && isAbsolute);
	function getLineToIndex(input) {
		if (input[lineToIndexCache]) return input[lineToIndexCache];
		let lines = input.css.split("\n");
		let lineToIndex = new Array(lines.length);
		let prevIndex = 0;
		for (let i = 0, l = lines.length; i < l; i++) {
			lineToIndex[i] = prevIndex;
			prevIndex += lines[i].length + 1;
		}
		input[lineToIndexCache] = lineToIndex;
		return lineToIndex;
	}
	var Input = class {
		get from() {
			return this.file || this.id;
		}
		constructor(css, opts = {}) {
			if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) throw new Error(`PostCSS received ${css} instead of CSS string`);
			this.css = css.toString();
			if (this.css[0] === "" || this.css[0] === "￾") {
				this.hasBOM = true;
				this.css = this.css.slice(1);
			} else this.hasBOM = false;
			this.document = this.css;
			if (opts.document) this.document = opts.document.toString();
			if (opts.from) {
				if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) this.file = opts.from;
				else this.file = resolve(opts.from);
			}
			if (pathAvailable && sourceMapAvailable) {
				let map = new PreviousMap(this.css, opts);
				if (map.text) {
					this.map = map;
					let file = map.consumer().file;
					if (!this.file && file) this.file = this.mapResolve(file);
				}
			}
			if (!this.file) this.id = "<input css " + nanoid(6) + ">";
			if (this.map) this.map.file = this.from;
		}
		error(message, line, column, opts = {}) {
			let endColumn, endLine, endOffset, offset, result;
			if (line && typeof line === "object") {
				let start = line;
				let end = column;
				if (typeof start.offset === "number") {
					offset = start.offset;
					let pos = this.fromOffset(offset);
					line = pos.line;
					column = pos.col;
				} else {
					line = start.line;
					column = start.column;
					offset = this.fromLineAndColumn(line, column);
				}
				if (typeof end.offset === "number") {
					endOffset = end.offset;
					let pos = this.fromOffset(endOffset);
					endLine = pos.line;
					endColumn = pos.col;
				} else {
					endLine = end.line;
					endColumn = end.column;
					endOffset = this.fromLineAndColumn(end.line, end.column);
				}
			} else if (!column) {
				offset = line;
				let pos = this.fromOffset(offset);
				line = pos.line;
				column = pos.col;
			} else offset = this.fromLineAndColumn(line, column);
			let origin = this.origin(line, column, endLine, endColumn);
			if (origin) result = new CssSyntaxError(message, origin.endLine === void 0 ? origin.line : {
				column: origin.column,
				line: origin.line
			}, origin.endLine === void 0 ? origin.column : {
				column: origin.endColumn,
				line: origin.endLine
			}, origin.source, origin.file, opts.plugin);
			else result = new CssSyntaxError(message, endLine === void 0 ? line : {
				column,
				line
			}, endLine === void 0 ? column : {
				column: endColumn,
				line: endLine
			}, this.css, this.file, opts.plugin);
			result.input = {
				column,
				endColumn,
				endLine,
				endOffset,
				line,
				offset,
				source: this.css
			};
			if (this.file) {
				if (pathToFileURL) result.input.url = pathToFileURL(this.file).toString();
				result.input.file = this.file;
			}
			return result;
		}
		fromLineAndColumn(line, column) {
			return getLineToIndex(this)[line - 1] + column - 1;
		}
		fromOffset(offset) {
			let lineToIndex = getLineToIndex(this);
			let lastLine = lineToIndex[lineToIndex.length - 1];
			let min = 0;
			if (offset >= lastLine) min = lineToIndex.length - 1;
			else {
				let max = lineToIndex.length - 2;
				let mid;
				while (min < max) {
					mid = min + (max - min >> 1);
					if (offset < lineToIndex[mid]) max = mid - 1;
					else if (offset >= lineToIndex[mid + 1]) min = mid + 1;
					else {
						min = mid;
						break;
					}
				}
			}
			return {
				col: offset - lineToIndex[min] + 1,
				line: min + 1
			};
		}
		mapResolve(file) {
			if (/^\w+:\/\//.test(file)) return file;
			return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
		}
		origin(line, column, endLine, endColumn) {
			if (!this.map) return false;
			let consumer = this.map.consumer();
			let from = consumer.originalPositionFor({
				column: column - 1,
				line
			});
			if (!from.source) return false;
			let to;
			if (typeof endLine === "number") {
				let toPosition = consumer.originalPositionFor({
					column: endColumn - 1,
					line: endLine
				});
				if (toPosition.source) to = toPosition;
			}
			let fromUrl;
			if (isAbsolute(from.source)) fromUrl = pathToFileURL(from.source);
			else fromUrl = new URL(from.source, this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile));
			let result = {
				column: from.column + 1,
				endColumn: to && to.column + 1,
				endLine: to && to.line,
				line: from.line,
				url: fromUrl.toString()
			};
			if (fromUrl.protocol === "file:") {
				if (fileURLToPath) result.file = fileURLToPath(fromUrl);
				else
 /* c8 ignore next 2 */
				throw new Error(`file: protocol is not available in this PostCSS build`);
			}
			let source = consumer.sourceContentFor(from.source);
			if (source) result.source = source;
			return result;
		}
		toJSON() {
			let json = {};
			for (let name of [
				"hasBOM",
				"css",
				"file",
				"id"
			]) if (this[name] != null) json[name] = this[name];
			if (this.map) {
				json.map = _objectSpread2({}, this.map);
				if (json.map.consumerCache) json.map.consumerCache = void 0;
			}
			return json;
		}
	};
	module.exports = Input;
	Input.default = Input;
	if (terminalHighlight && terminalHighlight.registerInput) terminalHighlight.registerInput(Input);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/root.js
var require_root$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Container = require_container$1();
	let LazyResult;
	let Processor;
	var Root = class extends Container {
		constructor(defaults) {
			super(defaults);
			this.type = "root";
			if (!this.nodes) this.nodes = [];
		}
		normalize(child, sample, type) {
			let keepBefore = /* @__PURE__ */ new Set();
			for (let node of Array.isArray(child) ? child : [child]) if (node && typeof node === "object" && !node.parent && node.raws && typeof node.raws.before !== "undefined") keepBefore.add(node.raws);
			let nodes = super.normalize(child);
			if (sample) {
				if (type === "prepend") {
					if (this.nodes.length > 1) sample.raws.before = this.nodes[1].raws.before;
					else delete sample.raws.before;
				} else if (this.first !== sample) {
					for (let node of nodes) if (!keepBefore.has(node.raws)) node.raws.before = sample.raws.before;
				}
			}
			return nodes;
		}
		removeChild(child, ignore) {
			let index = this.index(child);
			if (!ignore && index === 0 && this.nodes.length > 1) this.nodes[1].raws.before = this.nodes[index].raws.before;
			return super.removeChild(child);
		}
		toResult(opts = {}) {
			return new LazyResult(new Processor(), this, opts).stringify();
		}
	};
	Root.registerLazyResult = (dependant) => {
		LazyResult = dependant;
	};
	Root.registerProcessor = (dependant) => {
		Processor = dependant;
	};
	module.exports = Root;
	Root.default = Root;
	Container.registerRoot(Root);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/list.js
var require_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let list = {
		comma(string) {
			return list.split(string, [","], true);
		},
		space(string) {
			return list.split(string, [
				" ",
				"\n",
				"	"
			]);
		},
		split(string, separators, last) {
			if (typeof string !== "string") return [];
			let array = [];
			let current = "";
			let split = false;
			let func = 0;
			let inQuote = false;
			let prevQuote = "";
			let escape = false;
			for (let letter of string) {
				if (escape) escape = false;
				else if (letter === "\\") escape = true;
				else if (inQuote) {
					if (letter === prevQuote) inQuote = false;
				} else if (letter === "\"" || letter === "'") {
					inQuote = true;
					prevQuote = letter;
				} else if (letter === "(") func += 1;
				else if (letter === ")") {
					if (func > 0) func -= 1;
				} else if (func === 0) {
					if (separators.includes(letter)) split = true;
				}
				if (split) {
					let value = current.trim();
					if (last || value !== "") array.push(value);
					current = "";
					split = false;
				} else current += letter;
			}
			let value = current.trim();
			if (last || value !== "") array.push(value);
			return array;
		}
	};
	module.exports = list;
	list.default = list;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/rule.js
var require_rule = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Container = require_container$1();
	let list = require_list();
	var Rule = class extends Container {
		get selectors() {
			return list.comma(this.selector);
		}
		set selectors(values) {
			let match = this.selector ? this.selector.match(/,\s*/) : null;
			let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
			this.selector = values.join(sep);
		}
		constructor(defaults) {
			super(defaults);
			this.type = "rule";
			if (!this.nodes) this.nodes = [];
		}
	};
	module.exports = Rule;
	Rule.default = Rule;
	Container.registerRule(Rule);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/fromJSON.js
var require_fromJSON = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init_objectSpread2();
	init_objectWithoutProperties();
	const _excluded = ["inputId"];
	let AtRule = require_at_rule();
	let Comment = require_comment$1();
	let Declaration = require_declaration();
	let Input = require_input();
	let PreviousMap = require_previous_map();
	let Root = require_root$1();
	let Rule = require_rule();
	function hydrateInputs(json, inputs) {
		if (!json.inputs) return inputs;
		return json.inputs.map((input) => {
			let inputHydrated = _objectSpread2(_objectSpread2({}, input), {}, { __proto__: Input.prototype });
			if (inputHydrated.map) inputHydrated.map = _objectSpread2(_objectSpread2({}, inputHydrated.map), {}, { __proto__: PreviousMap.prototype });
			return inputHydrated;
		});
	}
	function constructNode(json, inputs, children) {
		let defaults = _objectSpread2({}, json);
		delete defaults.inputs;
		delete defaults.nodes;
		if (defaults.source) {
			let _defaults$source = defaults.source, { inputId } = _defaults$source;
			defaults.source = _objectWithoutProperties(_defaults$source, _excluded);
			if (inputId != null) defaults.source.input = inputs[inputId];
		}
		let node;
		if (defaults.type === "root") node = new Root(defaults);
		else if (defaults.type === "decl") node = new Declaration(defaults);
		else if (defaults.type === "rule") node = new Rule(defaults);
		else if (defaults.type === "comment") node = new Comment(defaults);
		else if (defaults.type === "atrule") node = new AtRule(defaults);
		else throw new Error("Unknown node type: " + json.type);
		if (children) {
			node.nodes = children;
			for (let child of children) child.parent = node;
		}
		return node;
	}
	function fromJSON(json, inputs) {
		if (Array.isArray(json)) return json.map((n) => fromJSON(n));
		let result;
		let stack = [{
			childIndex: 0,
			children: [],
			inputs: hydrateInputs(json, inputs),
			json
		}];
		while (stack.length > 0) {
			let frame = stack[stack.length - 1];
			let jsonNodes = frame.json.nodes;
			if (jsonNodes && frame.childIndex < jsonNodes.length) {
				let childJson = jsonNodes[frame.childIndex];
				frame.childIndex += 1;
				stack.push({
					childIndex: 0,
					children: [],
					inputs: hydrateInputs(childJson, frame.inputs),
					json: childJson
				});
				continue;
			}
			stack.pop();
			let node = constructNode(frame.json, frame.inputs, jsonNodes ? frame.children : void 0);
			if (stack.length > 0) stack[stack.length - 1].children.push(node);
			else result = node;
		}
		return result;
	}
	module.exports = fromJSON;
	fromJSON.default = fromJSON;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/map-generator.js
var require_map_generator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init__polyfill_node_buffer();
	let { dirname, relative, resolve, sep } = (init__polyfill_node_path(), __toCommonJS(_polyfill_node_path_exports));
	let { SourceMapConsumer, SourceMapGenerator } = require_lib();
	let { pathToFileURL } = (init__polyfill_node_url(), __toCommonJS(_polyfill_node_url_exports));
	let Input = require_input();
	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
	let pathAvailable = Boolean(dirname && resolve && relative && sep);
	var MapGenerator = class {
		constructor(stringify, root, opts, cssString) {
			this.stringify = stringify;
			this.mapOpts = opts.map || {};
			this.root = root;
			this.opts = opts;
			this.css = cssString;
			this.originalCSS = cssString;
			this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
			this.memoizedFileURLs = /* @__PURE__ */ new Map();
			this.memoizedPaths = /* @__PURE__ */ new Map();
			this.memoizedURLs = /* @__PURE__ */ new Map();
		}
		addAnnotation() {
			let content;
			if (this.isInline()) content = "data:application/json;base64," + this.toBase64(this.map.toString());
			else if (typeof this.mapOpts.annotation === "string") content = this.mapOpts.annotation;
			else if (typeof this.mapOpts.annotation === "function") content = this.mapOpts.annotation(this.opts.to, this.root);
			else content = this.outputFile() + ".map";
			let eol = "\n";
			if (this.css.includes("\r\n")) eol = "\r\n";
			this.css += eol + "/*# sourceMappingURL=" + content + " */";
		}
		applyPrevMaps() {
			for (let prev of this.previous()) {
				let from = this.toUrl(this.path(prev.file));
				let root = prev.root || dirname(prev.file);
				let map;
				if (this.mapOpts.sourcesContent === false) {
					map = new SourceMapConsumer(prev.text);
					if (map.sourcesContent) map.sourcesContent = null;
				} else map = prev.consumer();
				this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
			}
		}
		clearAnnotation() {
			if (this.mapOpts.annotation === false) return;
			if (this.root) {
				let node;
				for (let i = this.root.nodes.length - 1; i >= 0; i--) {
					node = this.root.nodes[i];
					if (node.type !== "comment") continue;
					if (node.text.startsWith("# sourceMappingURL=")) this.root.removeChild(i);
				}
			} else if (this.css) {
				let annotation = "/*# sourceMappingURL=";
				let startIndex;
				while ((startIndex = this.css.lastIndexOf(annotation)) !== -1) {
					let endIndex = this.css.indexOf("*/", startIndex + 21);
					if (endIndex === -1) break;
					while (startIndex > 0 && this.css[startIndex - 1] === "\n") startIndex--;
					this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2);
				}
			}
		}
		generate() {
			this.clearAnnotation();
			if (pathAvailable && sourceMapAvailable && this.isMap()) return this.generateMap();
			else {
				let result = "";
				this.stringify(this.root, (i) => {
					result += i;
				});
				return [result];
			}
		}
		generateMap() {
			if (this.root) this.generateString();
			else if (this.previous().length === 1) {
				let prev = this.previous()[0].consumer();
				prev.file = this.outputFile();
				this.map = SourceMapGenerator.fromSourceMap(prev, { ignoreInvalidMapping: true });
			} else {
				this.map = new SourceMapGenerator({
					file: this.outputFile(),
					ignoreInvalidMapping: true
				});
				this.map.addMapping({
					generated: {
						column: 0,
						line: 1
					},
					original: {
						column: 0,
						line: 1
					},
					source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
				});
			}
			if (this.isSourcesContent()) this.setSourcesContent();
			if (this.root && this.previous().length > 0) this.applyPrevMaps();
			if (this.isAnnotation()) this.addAnnotation();
			if (this.isInline()) return [this.css];
			else return [this.css, this.map];
		}
		generateString() {
			this.css = "";
			this.map = new SourceMapGenerator({
				file: this.outputFile(),
				ignoreInvalidMapping: true
			});
			let line = 1;
			let column = 1;
			let noSource = "<no source>";
			let mapping = {
				generated: {
					column: 0,
					line: 0
				},
				original: {
					column: 0,
					line: 0
				},
				source: ""
			};
			let last, lines;
			this.stringify(this.root, (str, node, type) => {
				this.css += str;
				if (node && type !== "end") {
					mapping.generated.line = line;
					mapping.generated.column = column - 1;
					if (node.source && node.source.start) {
						mapping.source = this.sourcePath(node);
						mapping.original.line = node.source.start.line;
						mapping.original.column = node.source.start.column - 1;
						this.map.addMapping(mapping);
					} else {
						mapping.source = noSource;
						mapping.original.line = 1;
						mapping.original.column = 0;
						this.map.addMapping(mapping);
					}
				}
				lines = str.match(/\n/g);
				if (lines) {
					line += lines.length;
					last = str.lastIndexOf("\n");
					column = str.length - last;
				} else column += str.length;
				if (node && type !== "start") {
					let p = node.parent || { raws: {} };
					if (!(node.type === "decl" || node.type === "atrule" && !node.nodes) || node !== p.last || p.raws.semicolon) {
						if (node.source && node.source.end) {
							mapping.source = this.sourcePath(node);
							mapping.original.line = node.source.end.line;
							mapping.original.column = node.source.end.column - 1;
							mapping.generated.line = line;
							mapping.generated.column = column - 2;
							this.map.addMapping(mapping);
						} else {
							mapping.source = noSource;
							mapping.original.line = 1;
							mapping.original.column = 0;
							mapping.generated.line = line;
							mapping.generated.column = column - 1;
							this.map.addMapping(mapping);
						}
					}
				}
			});
		}
		isAnnotation() {
			if (this.isInline()) return true;
			if (typeof this.mapOpts.annotation !== "undefined") return this.mapOpts.annotation;
			if (this.previous().length) return this.previous().some((i) => i.annotation);
			return true;
		}
		isInline() {
			if (typeof this.mapOpts.inline !== "undefined") return this.mapOpts.inline;
			let annotation = this.mapOpts.annotation;
			if (typeof annotation !== "undefined" && annotation !== true) return false;
			if (this.previous().length) return this.previous().some((i) => i.inline);
			return true;
		}
		isMap() {
			if (typeof this.opts.map !== "undefined") return !!this.opts.map;
			return this.previous().length > 0;
		}
		isSourcesContent() {
			if (typeof this.mapOpts.sourcesContent !== "undefined") return this.mapOpts.sourcesContent;
			if (this.previous().length) return this.previous().some((i) => i.withContent());
			return true;
		}
		outputFile() {
			if (this.opts.to) return this.path(this.opts.to);
			else if (this.opts.from) return this.path(this.opts.from);
			else return "to.css";
		}
		path(file) {
			if (this.mapOpts.absolute) return file;
			if (file.charCodeAt(0) === 60) return file;
			if (/^\w+:\/\//.test(file)) return file;
			let cached = this.memoizedPaths.get(file);
			if (cached) return cached;
			let from = this.opts.to ? dirname(this.opts.to) : ".";
			if (typeof this.mapOpts.annotation === "string") from = dirname(resolve(from, this.mapOpts.annotation));
			let path = relative(from, file);
			this.memoizedPaths.set(file, path);
			return path;
		}
		previous() {
			if (!this.previousMaps) {
				this.previousMaps = [];
				if (this.root) this.root.walk((node) => {
					if (node.source && node.source.input.map) {
						let map = node.source.input.map;
						if (!this.previousMaps.includes(map)) this.previousMaps.push(map);
					}
				});
				else {
					let input = new Input(this.originalCSS, this.opts);
					if (input.map) this.previousMaps.push(input.map);
				}
			}
			return this.previousMaps;
		}
		setSourcesContent() {
			let already = {};
			if (this.root) this.root.walk((node) => {
				if (node.source) {
					let from = node.source.input.from;
					if (from && !already[from]) {
						already[from] = true;
						let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
						this.map.setSourceContent(fromUrl, node.source.input.css);
					}
				}
			});
			else if (this.css) {
				let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
				this.map.setSourceContent(from, this.css);
			}
		}
		sourcePath(node) {
			if (this.mapOpts.from) return this.toUrl(this.mapOpts.from);
			else if (this.usesFileUrls) return this.toFileUrl(node.source.input.from);
			else return this.toUrl(this.path(node.source.input.from));
		}
		toBase64(str) {
			if (Buffer$1) return Buffer$1.from(str).toString("base64");
			else return window.btoa(unescape(encodeURIComponent(str)));
		}
		toFileUrl(path) {
			let cached = this.memoizedFileURLs.get(path);
			if (cached) return cached;
			if (pathToFileURL) {
				let fileURL = pathToFileURL(path).toString();
				this.memoizedFileURLs.set(path, fileURL);
				return fileURL;
			} else throw new Error("`map.absolute` option is not available in this PostCSS build");
		}
		toUrl(path) {
			let cached = this.memoizedURLs.get(path);
			if (cached) return cached;
			if (sep === "\\") path = path.replace(/\\/g, "/");
			let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
			this.memoizedURLs.set(path, url);
			return url;
		}
	};
	module.exports = MapGenerator;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/tokenize.js
var require_tokenize$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	const SINGLE_QUOTE = "'".charCodeAt(0);
	const DOUBLE_QUOTE = "\"".charCodeAt(0);
	const BACKSLASH = "\\".charCodeAt(0);
	const SLASH = "/".charCodeAt(0);
	const NEWLINE = "\n".charCodeAt(0);
	const SPACE = " ".charCodeAt(0);
	const FEED = "\f".charCodeAt(0);
	const TAB = "	".charCodeAt(0);
	const CR = "\r".charCodeAt(0);
	const OPEN_SQUARE = "[".charCodeAt(0);
	const CLOSE_SQUARE = "]".charCodeAt(0);
	const OPEN_PARENTHESES = "(".charCodeAt(0);
	const CLOSE_PARENTHESES = ")".charCodeAt(0);
	const OPEN_CURLY = "{".charCodeAt(0);
	const CLOSE_CURLY = "}".charCodeAt(0);
	const SEMICOLON = ";".charCodeAt(0);
	const ASTERISK = "*".charCodeAt(0);
	const COLON = ":".charCodeAt(0);
	const AT = "@".charCodeAt(0);
	const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
	const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
	const RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
	const RE_HEX_ESCAPE = /[\da-f]/i;
	module.exports = function tokenizer(input, options = {}) {
		let css = input.css.valueOf();
		let ignore = options.ignoreErrors;
		let code, content, escape, next, quote;
		let currentToken, escaped, escapePos, n, prev;
		let length = css.length;
		let pos = 0;
		let buffer = [];
		let returned = [];
		let lastBadParen = -1;
		function position() {
			return pos;
		}
		function unclosed(what) {
			throw input.error("Unclosed " + what, pos);
		}
		function endOfFile() {
			return returned.length === 0 && pos >= length;
		}
		function nextToken(opts) {
			if (returned.length) return returned.pop();
			if (pos >= length) return;
			let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
			code = css.charCodeAt(pos);
			switch (code) {
				case NEWLINE:
				case SPACE:
				case TAB:
				case CR:
				case FEED:
					next = pos;
					do {
						next += 1;
						code = css.charCodeAt(next);
					} while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
					currentToken = ["space", css.slice(pos, next)];
					pos = next - 1;
					break;
				case OPEN_SQUARE:
				case CLOSE_SQUARE:
				case OPEN_CURLY:
				case CLOSE_CURLY:
				case COLON:
				case SEMICOLON:
				case CLOSE_PARENTHESES: {
					let controlChar = String.fromCharCode(code);
					currentToken = [
						controlChar,
						controlChar,
						pos
					];
					break;
				}
				case OPEN_PARENTHESES:
					prev = buffer.length ? buffer.pop()[1] : "";
					n = css.charCodeAt(pos + 1);
					if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
						next = pos;
						do {
							escaped = false;
							next = css.indexOf(")", next + 1);
							if (next === -1) {
								if (ignore || ignoreUnclosed) {
									next = pos;
									break;
								} else unclosed("bracket");
							}
							escapePos = next;
							while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
								escapePos -= 1;
								escaped = !escaped;
							}
						} while (escaped);
						currentToken = [
							"brackets",
							css.slice(pos, next + 1),
							pos,
							next
						];
						pos = next;
					} else if (pos <= lastBadParen) currentToken = [
						"(",
						"(",
						pos
					];
					else {
						next = css.indexOf(")", pos + 1);
						content = css.slice(pos, next + 1);
						if (next === -1 || RE_BAD_BRACKET.test(content)) {
							lastBadParen = next === -1 ? length : next;
							currentToken = [
								"(",
								"(",
								pos
							];
						} else {
							currentToken = [
								"brackets",
								content,
								pos,
								next
							];
							pos = next;
						}
					}
					break;
				case SINGLE_QUOTE:
				case DOUBLE_QUOTE:
					quote = code === SINGLE_QUOTE ? "'" : "\"";
					next = pos;
					do {
						escaped = false;
						next = css.indexOf(quote, next + 1);
						if (next === -1) {
							if (ignore || ignoreUnclosed) {
								next = pos + 1;
								break;
							} else unclosed("string");
						}
						escapePos = next;
						while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
							escapePos -= 1;
							escaped = !escaped;
						}
					} while (escaped);
					currentToken = [
						"string",
						css.slice(pos, next + 1),
						pos,
						next
					];
					pos = next;
					break;
				case AT:
					RE_AT_END.lastIndex = pos + 1;
					RE_AT_END.test(css);
					if (RE_AT_END.lastIndex === 0) next = css.length - 1;
					else next = RE_AT_END.lastIndex - 2;
					currentToken = [
						"at-word",
						css.slice(pos, next + 1),
						pos,
						next
					];
					pos = next;
					break;
				case BACKSLASH:
					next = pos;
					escape = true;
					while (css.charCodeAt(next + 1) === BACKSLASH) {
						next += 1;
						escape = !escape;
					}
					code = css.charCodeAt(next + 1);
					if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
						next += 1;
						if (RE_HEX_ESCAPE.test(css.charAt(next))) {
							while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) next += 1;
							if (css.charCodeAt(next + 1) === SPACE) next += 1;
						}
					}
					currentToken = [
						"word",
						css.slice(pos, next + 1),
						pos,
						next
					];
					pos = next;
					break;
				default: if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
					next = css.indexOf("*/", pos + 2) + 1;
					if (next === 0) {
						if (ignore || ignoreUnclosed) next = css.length;
						else unclosed("comment");
					}
					currentToken = [
						"comment",
						css.slice(pos, next + 1),
						pos,
						next
					];
					pos = next;
				} else {
					RE_WORD_END.lastIndex = pos + 1;
					RE_WORD_END.test(css);
					if (RE_WORD_END.lastIndex === 0) next = css.length - 1;
					else next = RE_WORD_END.lastIndex - 2;
					currentToken = [
						"word",
						css.slice(pos, next + 1),
						pos,
						next
					];
					buffer.push(currentToken);
					pos = next;
				}
			}
			pos++;
			return currentToken;
		}
		function back(token) {
			returned.push(token);
		}
		return {
			back,
			endOfFile,
			nextToken,
			position
		};
	};
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parser.js
var require_parser$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let AtRule = require_at_rule();
	let Comment = require_comment$1();
	let Declaration = require_declaration();
	let Root = require_root$1();
	let Rule = require_rule();
	let tokenizer = require_tokenize$1();
	const SAFE_COMMENT_NEIGHBOR = {
		empty: true,
		space: true
	};
	function findLastWithPosition(tokens) {
		for (let i = tokens.length - 1; i >= 0; i--) {
			let token = tokens[i];
			let pos = token[3] || token[2];
			if (pos) return pos;
		}
	}
	function tokensToString(tokens, from, to) {
		let result = "";
		for (let i = from; i < to; i++) result += tokens[i][1];
		return result;
	}
	var Parser = class {
		constructor(input) {
			this.input = input;
			this.root = new Root();
			this.current = this.root;
			this.spaces = "";
			this.semicolon = false;
			this.createTokenizer();
			this.root.source = {
				input,
				start: {
					column: 1,
					line: 1,
					offset: 0
				}
			};
		}
		atrule(token) {
			let node = new AtRule();
			node.name = token[1].slice(1);
			if (node.name === "") this.unnamedAtrule(node, token);
			this.init(node, token[2]);
			let type;
			let prev;
			let shift;
			let last = false;
			let open = false;
			let params = [];
			let brackets = [];
			while (!this.tokenizer.endOfFile()) {
				token = this.tokenizer.nextToken();
				type = token[0];
				if (type === "(" || type === "[") brackets.push(type === "(" ? ")" : "]");
				else if (type === "{" && brackets.length > 0) brackets.push("}");
				else if (type === brackets[brackets.length - 1]) brackets.pop();
				if (brackets.length === 0) {
					if (type === ";") {
						node.source.end = this.getPosition(token[2]);
						node.source.end.offset++;
						this.semicolon = true;
						break;
					} else if (type === "{") {
						open = true;
						break;
					} else if (type === "}") {
						if (params.length > 0) {
							shift = params.length - 1;
							prev = params[shift];
							while (prev && prev[0] === "space") prev = params[--shift];
							if (prev) {
								node.source.end = this.getPosition(prev[3] || prev[2]);
								node.source.end.offset++;
							}
						}
						this.end(token);
						break;
					} else params.push(token);
				} else params.push(token);
				if (this.tokenizer.endOfFile()) {
					last = true;
					break;
				}
			}
			node.raws.between = this.spacesAndCommentsFromEnd(params);
			if (params.length) {
				node.raws.afterName = this.spacesAndCommentsFromStart(params);
				this.raw(node, "params", params);
				if (last) {
					token = params[params.length - 1];
					node.source.end = this.getPosition(token[3] || token[2]);
					node.source.end.offset++;
					this.spaces = node.raws.between;
					node.raws.between = "";
				}
			} else {
				node.raws.afterName = "";
				node.params = "";
			}
			if (open) {
				node.nodes = [];
				this.current = node;
			}
		}
		checkMissedSemicolon(tokens) {
			let colon = this.colon(tokens);
			if (colon === false) return;
			let founded = 0;
			let token;
			for (let j = colon - 1; j >= 0; j--) {
				token = tokens[j];
				if (token[0] !== "space") {
					founded += 1;
					if (founded === 2) break;
				}
			}
			throw this.input.error("Missed semicolon", token[0] === "word" ? token[3] + 1 : token[2]);
		}
		colon(tokens) {
			let brackets = 0;
			let prev, token, type;
			for (let [i, element] of tokens.entries()) {
				token = element;
				type = token[0];
				if (type === "(") brackets += 1;
				if (type === ")") brackets -= 1;
				if (brackets === 0 && type === ":") {
					if (!prev) this.doubleColon(token);
					else if (prev[0] === "word" && prev[1] === "progid") continue;
					else return i;
				}
				prev = token;
			}
			return false;
		}
		comment(token) {
			let node = new Comment();
			this.init(node, token[2]);
			node.source.end = this.getPosition(token[3] || token[2]);
			node.source.end.offset++;
			let text = token[1].slice(2, -2);
			if (!text.trim()) {
				node.text = "";
				node.raws.left = text;
				node.raws.right = "";
			} else {
				let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
				node.text = match[2];
				node.raws.left = match[1];
				node.raws.right = match[3];
			}
		}
		createTokenizer() {
			this.tokenizer = tokenizer(this.input);
		}
		decl(tokens, customProperty) {
			let node = new Declaration();
			this.init(node, tokens[0][2]);
			let last = tokens[tokens.length - 1];
			if (last[0] === ";") {
				this.semicolon = true;
				tokens.pop();
			}
			node.source.end = this.getPosition(last[3] || last[2] || findLastWithPosition(tokens));
			node.source.end.offset++;
			let start = 0;
			while (tokens[start][0] !== "word") {
				if (start === tokens.length - 1) this.unknownWord([tokens[start]]);
				start++;
			}
			node.raws.before += tokensToString(tokens, 0, start);
			node.source.start = this.getPosition(tokens[start][2]);
			let propStart = start;
			while (start < tokens.length) {
				let type = tokens[start][0];
				if (type === ":" || type === "space" || type === "comment") break;
				start++;
			}
			node.prop = tokensToString(tokens, propStart, start);
			let betweenStart = start;
			let token;
			while (start < tokens.length) {
				token = tokens[start];
				start++;
				if (token[0] === ":") break;
				if (token[0] === "word" && /\w/.test(token[1])) this.unknownWord([token]);
			}
			node.raws.between = tokensToString(tokens, betweenStart, start);
			if (node.prop[0] === "_" || node.prop[0] === "*") {
				node.raws.before += node.prop[0];
				node.prop = node.prop.slice(1);
			}
			let firstSpacesStart = start;
			while (start < tokens.length) {
				let next = tokens[start][0];
				if (next !== "space" && next !== "comment") break;
				start++;
			}
			let firstSpaces = tokens.slice(firstSpacesStart, start);
			tokens = tokens.slice(start);
			this.precheckMissedSemicolon(tokens);
			for (let i = tokens.length - 1; i >= 0; i--) {
				token = tokens[i];
				if (token[1].toLowerCase() === "!important") {
					node.important = true;
					let string = this.stringFrom(tokens, i);
					string = this.spacesFromEnd(tokens) + string;
					if (string !== " !important") node.raws.important = string;
					break;
				} else if (token[1].toLowerCase() === "important") {
					let cache = tokens.slice(0);
					let str = "";
					for (let j = i; j > 0; j--) {
						let type = cache[j][0];
						if (str.trim().startsWith("!") && type !== "space") break;
						str = cache.pop()[1] + str;
					}
					if (str.trim().startsWith("!")) {
						node.important = true;
						node.raws.important = str;
						tokens = cache;
					}
				}
				if (token[0] !== "space" && token[0] !== "comment") break;
			}
			if (tokens.some((i) => i[0] !== "space" && i[0] !== "comment")) {
				node.raws.between += firstSpaces.map((i) => i[1]).join("");
				firstSpaces = [];
			}
			this.raw(node, "value", firstSpaces.concat(tokens), customProperty);
			if (node.value.includes(":") && !customProperty) this.checkMissedSemicolon(tokens);
		}
		doubleColon(token) {
			throw this.input.error("Double colon", { offset: token[2] }, { offset: token[2] + token[1].length });
		}
		emptyRule(token) {
			let node = new Rule();
			this.init(node, token[2]);
			node.selector = "";
			node.raws.between = "";
			this.current = node;
		}
		end(token) {
			if (this.current.nodes && this.current.nodes.length) this.current.raws.semicolon = this.semicolon;
			this.semicolon = false;
			this.current.raws.after = (this.current.raws.after || "") + this.spaces;
			this.spaces = "";
			if (this.current.parent) {
				this.current.source.end = this.getPosition(token[2]);
				this.current.source.end.offset++;
				this.current = this.current.parent;
			} else this.unexpectedClose(token);
		}
		endFile() {
			if (this.current.parent) this.unclosedBlock();
			if (this.current.nodes && this.current.nodes.length) this.current.raws.semicolon = this.semicolon;
			this.current.raws.after = (this.current.raws.after || "") + this.spaces;
			this.root.source.end = this.getPosition(this.tokenizer.position());
		}
		freeSemicolon(token) {
			this.spaces += token[1];
			if (this.current.nodes) {
				let prev = this.current.nodes[this.current.nodes.length - 1];
				if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
					prev.raws.ownSemicolon = this.spaces;
					this.spaces = "";
					prev.source.end = this.getPosition(token[2]);
					prev.source.end.offset++;
				}
			}
		}
		getPosition(offset) {
			let pos = this.input.fromOffset(offset);
			return {
				column: pos.col,
				line: pos.line,
				offset
			};
		}
		init(node, offset) {
			this.current.push(node);
			node.source = {
				input: this.input,
				start: this.getPosition(offset)
			};
			node.raws.before = this.spaces;
			this.spaces = "";
			if (node.type !== "comment") this.semicolon = false;
		}
		other(start) {
			let end = false;
			let type = null;
			let colon = false;
			let bracket = null;
			let brackets = [];
			let customProperty = start[1].startsWith("--");
			let tokens = [];
			let token = start;
			while (token) {
				type = token[0];
				tokens.push(token);
				if (type === "(" || type === "[") {
					if (!bracket) bracket = token;
					brackets.push(type === "(" ? ")" : "]");
				} else if (customProperty && colon && type === "{") {
					if (!bracket) bracket = token;
					brackets.push("}");
				} else if (brackets.length === 0) {
					if (type === ";") {
						if (colon) {
							this.decl(tokens, customProperty);
							return;
						} else break;
					} else if (type === "{") {
						this.rule(tokens);
						return;
					} else if (type === "}") {
						this.tokenizer.back(tokens.pop());
						end = true;
						break;
					} else if (type === ":") colon = true;
				} else if (type === brackets[brackets.length - 1]) {
					brackets.pop();
					if (brackets.length === 0) bracket = null;
				}
				token = this.tokenizer.nextToken();
			}
			if (this.tokenizer.endOfFile()) end = true;
			if (brackets.length > 0) this.unclosedBracket(bracket);
			if (end && colon) {
				if (!customProperty) while (tokens.length) {
					token = tokens[tokens.length - 1][0];
					if (token !== "space" && token !== "comment") break;
					this.tokenizer.back(tokens.pop());
				}
				this.decl(tokens, customProperty);
			} else this.unknownWord(tokens);
		}
		parse() {
			let token;
			while (!this.tokenizer.endOfFile()) {
				token = this.tokenizer.nextToken();
				switch (token[0]) {
					case "space":
						this.spaces += token[1];
						break;
					case ";":
						this.freeSemicolon(token);
						break;
					case "}":
						this.end(token);
						break;
					case "comment":
						this.comment(token);
						break;
					case "at-word":
						this.atrule(token);
						break;
					case "{":
						this.emptyRule(token);
						break;
					default: this.other(token);
				}
			}
			this.endFile();
		}
		precheckMissedSemicolon() {}
		raw(node, prop, tokens, customProperty) {
			let token, type;
			let length = tokens.length;
			let value = "";
			let clean = true;
			let next, prev;
			for (let i = 0; i < length; i += 1) {
				token = tokens[i];
				type = token[0];
				if (type === "space" && i === length - 1 && !customProperty) clean = false;
				else if (type === "comment") {
					prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
					next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
					if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
						if (value.slice(-1) === ",") clean = false;
						else value += token[1];
					} else clean = false;
				} else value += token[1];
			}
			if (!clean) {
				let raw = tokens.reduce((all, i) => all + i[1], "");
				node.raws[prop] = {
					raw,
					value
				};
			}
			node[prop] = value;
		}
		rule(tokens) {
			tokens.pop();
			let node = new Rule();
			this.init(node, tokens[0][2]);
			node.raws.between = this.spacesAndCommentsFromEnd(tokens);
			this.raw(node, "selector", tokens);
			this.current = node;
		}
		spacesAndCommentsFromEnd(tokens) {
			let lastTokenType;
			let spaces = "";
			while (tokens.length) {
				lastTokenType = tokens[tokens.length - 1][0];
				if (lastTokenType !== "space" && lastTokenType !== "comment") break;
				spaces = tokens.pop()[1] + spaces;
			}
			return spaces;
		}
		spacesAndCommentsFromStart(tokens) {
			let next;
			let spaces = "";
			while (tokens.length) {
				next = tokens[0][0];
				if (next !== "space" && next !== "comment") break;
				spaces += tokens.shift()[1];
			}
			return spaces;
		}
		spacesFromEnd(tokens) {
			let lastTokenType;
			let spaces = "";
			while (tokens.length) {
				lastTokenType = tokens[tokens.length - 1][0];
				if (lastTokenType !== "space") break;
				spaces = tokens.pop()[1] + spaces;
			}
			return spaces;
		}
		stringFrom(tokens, from) {
			let result = "";
			for (let i = from; i < tokens.length; i++) result += tokens[i][1];
			tokens.splice(from, tokens.length - from);
			return result;
		}
		unclosedBlock() {
			let pos = this.current.source.start;
			throw this.input.error("Unclosed block", pos.line, pos.column);
		}
		unclosedBracket(bracket) {
			throw this.input.error("Unclosed bracket", { offset: bracket[2] }, { offset: bracket[2] + 1 });
		}
		unexpectedClose(token) {
			throw this.input.error("Unexpected }", { offset: token[2] }, { offset: token[2] + 1 });
		}
		unknownWord(tokens) {
			throw this.input.error("Unknown word " + tokens[0][1], { offset: tokens[0][2] }, { offset: tokens[0][2] + tokens[0][1].length });
		}
		unnamedAtrule(node, token) {
			throw this.input.error("At-rule without name", { offset: token[2] }, { offset: token[2] + token[1].length });
		}
	};
	module.exports = Parser;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/parse.js
var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Container = require_container$1();
	let Input = require_input();
	let Parser = require_parser$1();
	function parse(css, opts) {
		let input = new Input(css, opts);
		let parser = new Parser(input);
		try {
			parser.parse();
		} catch (e) {
			if (e.name === "CssSyntaxError" && opts && opts.from) {
				if (/\.scss$/i.test(opts.from)) e.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
				else if (/\.sass/i.test(opts.from)) e.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
				else if (/\.less$/i.test(opts.from)) e.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
			}
			throw e;
		}
		return parser.root;
	}
	module.exports = parse;
	parse.default = parse;
	Container.registerParse(parse);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/warning.js
var require_warning = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Container = require_container$1();
	let { my } = require_symbols();
	var Warning = class {
		constructor(text, opts = {}) {
			this.type = "warning";
			this.text = text;
			if (opts.node && opts.node.source) {
				if (!opts.node[my]) Container.rebuild(opts.node);
				let range = opts.node.rangeBy(opts);
				this.line = range.start.line;
				this.column = range.start.column;
				this.endLine = range.end.line;
				this.endColumn = range.end.column;
			}
			for (let opt in opts) this[opt] = opts[opt];
		}
		toString() {
			if (this.node) return this.node.error(this.text, {
				index: this.index,
				plugin: this.plugin,
				word: this.word
			}).message;
			if (this.plugin) return this.plugin + ": " + this.text;
			return this.text;
		}
	};
	module.exports = Warning;
	Warning.default = Warning;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/result.js
var require_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Warning = require_warning();
	var Result = class {
		get content() {
			return this.css;
		}
		constructor(processor, root, opts) {
			this.processor = processor;
			this.messages = [];
			this.root = root;
			this.opts = opts;
			this.css = "";
			this.map = void 0;
		}
		toString() {
			return this.css;
		}
		warn(text, opts = {}) {
			if (!opts.plugin) {
				if (this.lastPlugin && this.lastPlugin.postcssPlugin) opts.plugin = this.lastPlugin.postcssPlugin;
			}
			let warning = new Warning(text, opts);
			this.messages.push(warning);
			return warning;
		}
		warnings() {
			return this.messages.filter((i) => i.type === "warning");
		}
	};
	module.exports = Result;
	Result.default = Result;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/warn-once.js
var require_warn_once = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let printed = {};
	module.exports = function warnOnce(message) {
		if (printed[message]) return;
		printed[message] = true;
		if (typeof console !== "undefined" && console.warn) console.warn(message);
	};
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/lazy-result.js
var require_lazy_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init_objectSpread2();
	init_asyncToGenerator();
	let Container = require_container$1();
	let Document = require_document();
	let MapGenerator = require_map_generator();
	let parse = require_parse();
	let Result = require_result();
	let Root = require_root$1();
	let stringify = require_stringify();
	let { isClean, my } = require_symbols();
	let warnOnce = require_warn_once();
	const TYPE_TO_CLASS_NAME = {
		atrule: "AtRule",
		comment: "Comment",
		decl: "Declaration",
		document: "Document",
		root: "Root",
		rule: "Rule"
	};
	const PLUGIN_PROPS = {
		AtRule: true,
		AtRuleExit: true,
		Comment: true,
		CommentExit: true,
		Declaration: true,
		DeclarationExit: true,
		Document: true,
		DocumentExit: true,
		Once: true,
		OnceExit: true,
		postcssPlugin: true,
		prepare: true,
		Root: true,
		RootExit: true,
		Rule: true,
		RuleExit: true
	};
	const NOT_VISITORS = {
		Once: true,
		postcssPlugin: true,
		prepare: true
	};
	const CHILDREN = 0;
	function isPromise(obj) {
		return typeof obj === "object" && typeof obj.then === "function";
	}
	function getEvents(node) {
		let key = false;
		let type = TYPE_TO_CLASS_NAME[node.type];
		if (node.type === "decl") key = node.prop.toLowerCase();
		else if (node.type === "atrule") key = node.name.toLowerCase();
		if (key && node.append) return [
			type,
			type + "-" + key,
			CHILDREN,
			type + "Exit",
			type + "Exit-" + key
		];
		else if (key) return [
			type,
			type + "-" + key,
			type + "Exit",
			type + "Exit-" + key
		];
		else if (node.append) return [
			type,
			CHILDREN,
			type + "Exit"
		];
		else return [type, type + "Exit"];
	}
	function toStack(node) {
		let events;
		if (node.type === "document") events = [
			"Document",
			CHILDREN,
			"DocumentExit"
		];
		else if (node.type === "root") events = [
			"Root",
			CHILDREN,
			"RootExit"
		];
		else events = getEvents(node);
		return {
			eventIndex: 0,
			events,
			iterator: 0,
			node,
			visitorIndex: 0,
			visitors: []
		};
	}
	function cleanMarks(node) {
		let stack = [node];
		while (stack.length > 0) {
			let next = stack.pop();
			next[isClean] = false;
			if (next.nodes) for (let i of next.nodes) stack.push(i);
		}
		return node;
	}
	let postcss = {};
	var LazyResult = class LazyResult {
		get content() {
			return this.stringify().content;
		}
		get css() {
			return this.stringify().css;
		}
		get map() {
			return this.stringify().map;
		}
		get messages() {
			return this.sync().messages;
		}
		get opts() {
			return this.result.opts;
		}
		get processor() {
			return this.result.processor;
		}
		get root() {
			return this.sync().root;
		}
		get [Symbol.toStringTag]() {
			return "LazyResult";
		}
		constructor(processor, css, opts) {
			this.stringified = false;
			this.processed = false;
			let root;
			if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) root = cleanMarks(css);
			else if (css instanceof LazyResult || css instanceof Result) {
				root = cleanMarks(css.root);
				if (css.map) {
					if (typeof opts.map === "undefined") opts.map = {};
					if (!opts.map.inline) opts.map.inline = false;
					opts.map.prev = css.map;
				}
			} else {
				let parser = parse;
				if (opts.syntax) parser = opts.syntax.parse;
				if (opts.parser) parser = opts.parser;
				if (parser.parse) parser = parser.parse;
				try {
					root = parser(css, opts);
				} catch (error) {
					this.processed = true;
					this.error = error;
				}
				if (root && !root[my])
 /* c8 ignore next 2 */
				Container.rebuild(root);
			}
			this.result = new Result(processor, root, opts);
			this.helpers = _objectSpread2(_objectSpread2({}, postcss), {}, {
				postcss,
				result: this.result
			});
			this.plugins = this.processor.plugins.map((plugin) => {
				if (typeof plugin === "object" && plugin.prepare) return _objectSpread2(_objectSpread2({}, plugin), plugin.prepare(this.result));
				else return plugin;
			});
		}
		async() {
			if (this.error) return Promise.reject(this.error);
			if (this.processed) return Promise.resolve(this.result);
			if (!this.processing) this.processing = this.runAsync();
			return this.processing;
		}
		catch(onRejected) {
			return this.async().catch(onRejected);
		}
		finally(onFinally) {
			return this.async().then(onFinally, onFinally);
		}
		getAsyncError() {
			throw new Error("Use process(css).then(cb) to work with async plugins");
		}
		handleError(error, node) {
			let plugin = this.result.lastPlugin;
			try {
				if (node) node.addToError(error);
				this.error = error;
				if (error.name === "CssSyntaxError" && !error.plugin) {
					error.plugin = plugin.postcssPlugin;
					error.setMessage();
				} else if (plugin.postcssVersion) {
					let pluginName = plugin.postcssPlugin;
					let pluginVer = plugin.postcssVersion;
					let runtimeVer = this.result.processor.version;
					let a = pluginVer.split(".");
					let b = runtimeVer.split(".");
					if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) console.error("Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below.");
				}
			} catch (err) {
				/* c8 ignore next 3 */
				if (console && console.error) console.error(err);
			}
			return error;
		}
		prepareVisitors() {
			this.listeners = {};
			let add = (plugin, type, cb) => {
				if (!this.listeners[type]) this.listeners[type] = [];
				this.listeners[type].push([plugin, cb]);
			};
			for (let plugin of this.plugins) if (typeof plugin === "object") for (let event in plugin) {
				if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) throw new Error(`Unknown event ${event} in ${plugin.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`);
				if (!NOT_VISITORS[event]) {
					if (typeof plugin[event] === "object") for (let filter in plugin[event]) if (filter === "*") add(plugin, event, plugin[event][filter]);
					else add(plugin, event + "-" + filter.toLowerCase(), plugin[event][filter]);
					else if (typeof plugin[event] === "function") add(plugin, event, plugin[event]);
				}
			}
			this.hasListener = Object.keys(this.listeners).length > 0;
		}
		runAsync() {
			var _this = this;
			return _asyncToGenerator(function* () {
				_this.plugin = 0;
				for (let i = 0; i < _this.plugins.length; i++) {
					let plugin = _this.plugins[i];
					let promise = _this.runOnRoot(plugin);
					if (isPromise(promise)) try {
						yield promise;
					} catch (error) {
						throw _this.handleError(error);
					}
				}
				_this.prepareVisitors();
				if (_this.hasListener) {
					let root = _this.result.root;
					while (!root[isClean]) {
						root[isClean] = true;
						let stack = [toStack(root)];
						while (stack.length > 0) {
							let promise = _this.visitTick(stack);
							if (isPromise(promise)) try {
								yield promise;
							} catch (e) {
								let node = stack[stack.length - 1].node;
								throw _this.handleError(e, node);
							}
						}
					}
					if (_this.listeners.OnceExit) for (let [plugin, visitor] of _this.listeners.OnceExit) {
						_this.result.lastPlugin = plugin;
						try {
							if (root.type === "document") {
								let roots = root.nodes.map((subRoot) => visitor(subRoot, _this.helpers));
								yield Promise.all(roots);
							} else yield visitor(root, _this.helpers);
						} catch (e) {
							throw _this.handleError(e);
						}
					}
				}
				_this.processed = true;
				return _this.stringify();
			})();
		}
		runOnRoot(plugin) {
			this.result.lastPlugin = plugin;
			try {
				if (typeof plugin === "object" && plugin.Once) {
					if (this.result.root.type === "document") {
						let roots = this.result.root.nodes.map((root) => plugin.Once(root, this.helpers));
						if (isPromise(roots[0])) return Promise.all(roots);
						return roots;
					}
					return plugin.Once(this.result.root, this.helpers);
				} else if (typeof plugin === "function") return plugin(this.result.root, this.result);
			} catch (error) {
				throw this.handleError(error);
			}
		}
		stringify() {
			if (this.error) throw this.error;
			if (this.stringified) return this.result;
			this.stringified = true;
			this.sync();
			let opts = this.result.opts;
			let str = stringify;
			if (opts.syntax) str = opts.syntax.stringify;
			if (opts.stringifier) str = opts.stringifier;
			if (str.stringify) str = str.stringify;
			let rootSource = this.result.root.source;
			if (opts.map === void 0 && !(rootSource && rootSource.input && rootSource.input.map)) {
				let result = "";
				str(this.result.root, (i) => {
					result += i;
				});
				this.result.css = result;
				return this.result;
			}
			let data = new MapGenerator(str, this.result.root, this.result.opts).generate();
			this.result.css = data[0];
			this.result.map = data[1];
			return this.result;
		}
		sync() {
			if (this.error) throw this.error;
			if (this.processed) return this.result;
			this.processed = true;
			if (this.processing) throw this.getAsyncError();
			for (let plugin of this.plugins) if (isPromise(this.runOnRoot(plugin))) throw this.getAsyncError();
			this.prepareVisitors();
			if (this.hasListener) {
				let root = this.result.root;
				while (!root[isClean]) {
					root[isClean] = true;
					this.walkSync(root);
				}
				if (this.listeners.OnceExit) {
					if (root.type === "document") for (let subRoot of root.nodes) this.visitSync(this.listeners.OnceExit, subRoot);
					else this.visitSync(this.listeners.OnceExit, root);
				}
			}
			return this.result;
		}
		then(onFulfilled, onRejected) {
			if (!("from" in this.opts)) warnOnce("Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning.");
			return this.async().then(onFulfilled, onRejected);
		}
		toString() {
			return this.css;
		}
		visitSync(visitors, node) {
			for (let [plugin, visitor] of visitors) {
				this.result.lastPlugin = plugin;
				let promise;
				try {
					promise = visitor(node, this.helpers);
				} catch (e) {
					throw this.handleError(e, node.proxyOf);
				}
				if (node.type !== "root" && node.type !== "document" && !node.parent) return true;
				if (isPromise(promise)) throw this.getAsyncError();
			}
		}
		visitTick(stack) {
			let visit = stack[stack.length - 1];
			let { node, visitors } = visit;
			if (node.type !== "root" && node.type !== "document" && !node.parent) {
				stack.pop();
				return;
			}
			if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
				let [plugin, visitor] = visitors[visit.visitorIndex];
				visit.visitorIndex += 1;
				if (visit.visitorIndex === visitors.length) {
					visit.visitors = [];
					visit.visitorIndex = 0;
				}
				this.result.lastPlugin = plugin;
				try {
					return visitor(node.toProxy(), this.helpers);
				} catch (e) {
					throw this.handleError(e, node);
				}
			}
			if (visit.iterator !== 0) {
				let iterator = visit.iterator;
				if (visit.descending) {
					visit.descending = false;
					node.indexes[iterator] += 1;
				}
				let child;
				while (child = node.nodes[node.indexes[iterator]]) {
					if (!child[isClean]) {
						child[isClean] = true;
						visit.descending = true;
						stack.push(toStack(child));
						return;
					}
					node.indexes[iterator] += 1;
				}
				visit.iterator = 0;
				delete node.indexes[iterator];
			}
			let events = visit.events;
			while (visit.eventIndex < events.length) {
				let event = events[visit.eventIndex];
				visit.eventIndex += 1;
				if (event === CHILDREN) {
					if (node.nodes && node.nodes.length) {
						node[isClean] = true;
						visit.iterator = node.getIterator();
					}
					return;
				} else if (this.listeners[event]) {
					visit.visitors = this.listeners[event];
					return;
				}
			}
			stack.pop();
		}
		walkSync(node) {
			node[isClean] = true;
			let stack = [{
				eventIndex: 0,
				events: getEvents(node),
				iterator: 0,
				node
			}];
			while (stack.length > 0) {
				let visit = stack[stack.length - 1];
				let visitNode = visit.node;
				if (visit.iterator !== 0) {
					let iterator = visit.iterator;
					if (visit.descending) {
						visit.descending = false;
						visitNode.indexes[iterator] += 1;
					}
					let child;
					let descended = false;
					while (child = visitNode.nodes[visitNode.indexes[iterator]]) {
						if (!child[isClean]) {
							child[isClean] = true;
							visit.descending = true;
							stack.push({
								eventIndex: 0,
								events: getEvents(child),
								iterator: 0,
								node: child
							});
							descended = true;
							break;
						}
						visitNode.indexes[iterator] += 1;
					}
					if (descended) continue;
					visit.iterator = 0;
					delete visitNode.indexes[iterator];
				}
				if (visit.eventIndex < visit.events.length) {
					let event = visit.events[visit.eventIndex];
					visit.eventIndex += 1;
					if (event === CHILDREN) {
						if (visitNode.nodes && visitNode.nodes.length) visit.iterator = visitNode.getIterator();
					} else {
						let visitors = this.listeners[event];
						if (visitors) {
							if (this.visitSync(visitors, visitNode.toProxy())) stack.pop();
						}
					}
					continue;
				}
				stack.pop();
			}
		}
		warnings() {
			return this.sync().warnings();
		}
	};
	LazyResult.registerPostcss = (dependant) => {
		postcss = dependant;
	};
	module.exports = LazyResult;
	LazyResult.default = LazyResult;
	Root.registerLazyResult(LazyResult);
	Document.registerLazyResult(LazyResult);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/no-work-result.js
var require_no_work_result = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let MapGenerator = require_map_generator();
	let parse = require_parse();
	let Result = require_result();
	let stringify = require_stringify();
	let warnOnce = require_warn_once();
	var NoWorkResult = class {
		get content() {
			return this.result.css;
		}
		get css() {
			return this.result.css;
		}
		get map() {
			return this.result.map;
		}
		get messages() {
			return [];
		}
		get opts() {
			return this.result.opts;
		}
		get processor() {
			return this.result.processor;
		}
		get root() {
			if (this._root) return this._root;
			let root;
			let parser = parse;
			try {
				root = parser(this._css, this._opts);
			} catch (error) {
				this.error = error;
			}
			if (this.error) throw this.error;
			else {
				this._root = root;
				return root;
			}
		}
		get [Symbol.toStringTag]() {
			return "NoWorkResult";
		}
		constructor(processor, css, opts) {
			css = css.toString();
			this.stringified = false;
			this._processor = processor;
			this._css = css;
			this._opts = opts;
			this._map = void 0;
			let str = stringify;
			this.result = new Result(this._processor, void 0, this._opts);
			this.result.css = css;
			let self = this;
			Object.defineProperty(this.result, "root", { get() {
				return self.root;
			} });
			let map = new MapGenerator(str, void 0, this._opts, css);
			if (map.isMap()) {
				let [generatedCSS, generatedMap] = map.generate();
				if (generatedCSS) this.result.css = generatedCSS;
				if (generatedMap) this.result.map = generatedMap;
			} else {
				map.clearAnnotation();
				this.result.css = map.css;
			}
		}
		async() {
			if (this.error) return Promise.reject(this.error);
			return Promise.resolve(this.result);
		}
		catch(onRejected) {
			return this.async().catch(onRejected);
		}
		finally(onFinally) {
			return this.async().then(onFinally, onFinally);
		}
		sync() {
			if (this.error) throw this.error;
			return this.result;
		}
		then(onFulfilled, onRejected) {
			if (!("from" in this._opts)) warnOnce("Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning.");
			return this.async().then(onFulfilled, onRejected);
		}
		toString() {
			return this._css;
		}
		warnings() {
			return [];
		}
	};
	module.exports = NoWorkResult;
	NoWorkResult.default = NoWorkResult;
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/processor.js
var require_processor$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	let Document = require_document();
	let LazyResult = require_lazy_result();
	let NoWorkResult = require_no_work_result();
	let Root = require_root$1();
	var Processor = class {
		constructor(plugins = []) {
			this.version = "8.5.28";
			this.plugins = this.normalize(plugins);
		}
		normalize(plugins) {
			let normalized = [];
			for (let i of plugins) {
				if (i.postcss === true) i = i();
				else if (i.postcss) i = i.postcss;
				if (typeof i === "object" && Array.isArray(i.plugins)) normalized = normalized.concat(i.plugins);
				else if (typeof i === "object" && i.postcssPlugin) normalized.push(i);
				else if (typeof i === "function") normalized.push(i);
				else if (typeof i === "object" && (i.parse || i.stringify)) throw new Error("PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation.");
				else throw new Error(i + " is not a PostCSS plugin");
			}
			return normalized;
		}
		process(css, opts = {}) {
			if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) return new NoWorkResult(this, css, opts);
			else return new LazyResult(this, css, opts);
		}
		use(plugin) {
			this.plugins = this.plugins.concat(this.normalize([plugin]));
			return this;
		}
	};
	module.exports = Processor;
	Processor.default = Processor;
	Root.registerProcessor(Processor);
	Document.registerProcessor(Processor);
}));
//#endregion
//#region node_modules/.pnpm/postcss@8.5.28/node_modules/postcss/lib/postcss.mjs
var import_postcss = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	init__polyfill_node_process();
	let AtRule = require_at_rule();
	let Comment = require_comment$1();
	let Container = require_container$1();
	let CssSyntaxError = require_css_syntax_error();
	let Declaration = require_declaration();
	let Document = require_document();
	let fromJSON = require_fromJSON();
	let Input = require_input();
	let LazyResult = require_lazy_result();
	let list = require_list();
	let Node = require_node$1();
	let parse = require_parse();
	let Processor = require_processor$1();
	let Result = require_result();
	let Root = require_root$1();
	let Rule = require_rule();
	let stringify = require_stringify();
	let Warning = require_warning();
	function postcss(...plugins) {
		if (plugins.length === 1 && Array.isArray(plugins[0])) plugins = plugins[0];
		return new Processor(plugins);
	}
	postcss.plugin = function plugin(name, initializer) {
		let warningPrinted = false;
		function creator(...args) {
			if (console && console.warn && !warningPrinted) {
				warningPrinted = true;
				console.warn(name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration");
				if (browser$1.env.LANG && browser$1.env.LANG.startsWith("zh"))
 /* c8 ignore next 7 */
				console.warn(name + ": 里面 postcss.plugin 被弃用. 迁移指南:\nhttps://www.w3ctech.com/topic/2226");
			}
			let transformer = initializer(...args);
			transformer.postcssPlugin = name;
			transformer.postcssVersion = new Processor().version;
			return transformer;
		}
		let cache;
		Object.defineProperty(creator, "postcss", { get() {
			if (!cache) cache = creator();
			return cache;
		} });
		creator.process = function(css, processOpts, pluginOpts) {
			return postcss([creator(pluginOpts)]).process(css, processOpts);
		};
		return creator;
	};
	postcss.stringify = stringify;
	postcss.parse = parse;
	postcss.fromJSON = fromJSON;
	postcss.list = list;
	postcss.comment = (defaults) => new Comment(defaults);
	postcss.atRule = (defaults) => new AtRule(defaults);
	postcss.decl = (defaults) => new Declaration(defaults);
	postcss.rule = (defaults) => new Rule(defaults);
	postcss.root = (defaults) => new Root(defaults);
	postcss.document = (defaults) => new Document(defaults);
	postcss.CssSyntaxError = CssSyntaxError;
	postcss.Declaration = Declaration;
	postcss.Container = Container;
	postcss.Processor = Processor;
	postcss.Document = Document;
	postcss.Comment = Comment;
	postcss.Warning = Warning;
	postcss.AtRule = AtRule;
	postcss.Result = Result;
	postcss.Input = Input;
	postcss.Rule = Rule;
	postcss.Root = Root;
	postcss.Node = Node;
	LazyResult.registerPostcss(postcss);
	module.exports = postcss;
	postcss.default = postcss;
})))(), 1);
var postcss_default = import_postcss.default;
import_postcss.default.stringify;
import_postcss.default.fromJSON;
import_postcss.default.plugin;
import_postcss.default.parse;
import_postcss.default.list;
import_postcss.default.document;
import_postcss.default.comment;
import_postcss.default.atRule;
import_postcss.default.rule;
import_postcss.default.decl;
import_postcss.default.root;
import_postcss.default.CssSyntaxError;
import_postcss.default.Declaration;
import_postcss.default.Container;
import_postcss.default.Processor;
import_postcss.default.Document;
import_postcss.default.Comment;
import_postcss.default.Warning;
import_postcss.default.AtRule;
import_postcss.default.Result;
import_postcss.default.Input;
const Rule = import_postcss.default.Rule;
import_postcss.default.Root;
import_postcss.default.Node;
//#endregion
//#region packages/compiler-sfc/src/style/pluginTrim.ts
const trimPlugin = () => {
	return {
		postcssPlugin: "vue-sfc-trim",
		Once(root) {
			root.walk(({ type, raws }) => {
				if (type === "rule" || type === "atrule") {
					if (raws.before) raws.before = "\n";
					if ("after" in raws && raws.after) raws.after = "\n";
				}
			});
		}
	};
};
trimPlugin.postcss = true;
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/util/unesc.js
var require_unesc = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.default = unesc;
	/**
	*
	* @param {string} str
	* @returns {[string, number]|undefined}
	*/
	function gobbleHex(str) {
		var lower = str.toLowerCase();
		var hex = "";
		var spaceTerminated = false;
		for (var i = 0; i < 6 && lower[i] !== void 0; i++) {
			var code = lower.charCodeAt(i);
			var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
			spaceTerminated = code === 32;
			if (!valid) break;
			hex += lower[i];
		}
		if (hex.length === 0) return;
		var codePoint = parseInt(hex, 16);
		if (codePoint >= 55296 && codePoint <= 57343 || codePoint === 0 || codePoint > 1114111) return ["�", hex.length + (spaceTerminated ? 1 : 0)];
		return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
	}
	var CONTAINS_ESCAPE = /\\/;
	function unesc(str) {
		if (!CONTAINS_ESCAPE.test(str)) return str;
		var ret = "";
		for (var i = 0; i < str.length; i++) {
			if (str[i] === "\\") {
				var gobbled = gobbleHex(str.slice(i + 1, i + 7));
				if (gobbled !== void 0) {
					ret += gobbled[0];
					i += gobbled[1];
					continue;
				}
				if (str[i + 1] === "\\") {
					ret += "\\";
					i++;
					continue;
				}
				if (str.length === i + 1) ret += str[i];
				continue;
			}
			ret += str[i];
		}
		return ret;
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/util/getProp.js
var require_getProp = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.default = getProp;
	function getProp(obj) {
		var props = [];
		for (var _i = 1; _i < arguments.length; _i++) props[_i - 1] = arguments[_i];
		while (props.length > 0) {
			var prop = props.shift();
			if (!obj[prop]) return;
			obj = obj[prop];
		}
		return obj;
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/util/ensureObject.js
var require_ensureObject = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.default = ensureObject;
	function ensureObject(obj) {
		var props = [];
		for (var _i = 1; _i < arguments.length; _i++) props[_i - 1] = arguments[_i];
		while (props.length > 0) {
			var prop = props.shift();
			if (!obj[prop]) obj[prop] = {};
			obj = obj[prop];
		}
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/util/stripComments.js
var require_stripComments = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.default = stripComments;
	function stripComments(str) {
		var s = "";
		var commentStart = str.indexOf("/*");
		var lastEnd = 0;
		while (commentStart >= 0) {
			s = s + str.slice(lastEnd, commentStart);
			var commentEnd = str.indexOf("*/", commentStart + 2);
			if (commentEnd < 0) return s;
			lastEnd = commentEnd + 2;
			commentStart = str.indexOf("/*", lastEnd);
		}
		s = s + str.slice(lastEnd);
		return s;
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/util/maxNestingDepth.js
var require_maxNestingDepth = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.MAX_NESTING_DEPTH = void 0;
	exports.default = resolveMaxNestingDepth;
	/**
	* The default maximum selector nesting depth allowed when parsing or
	* serializing a selector. Going beyond this would otherwise recurse deeply
	* enough to overflow the call stack (CVE-2026-9358 / CWE-674). Real-world
	* selectors never get anywhere near this, so it acts purely as a safety net
	* that turns an uncatchable stack overflow into a catchable error.
	*/
	exports.MAX_NESTING_DEPTH = 256;
	/**
	* Coerce a user-supplied nesting-depth limit into a safe value. Anything that
	* is not a non-negative safe integer (NaN, Infinity, negative numbers, or a
	* non-number) would disable or break the guard, so it falls back to the
	* default.
	*
	* @param {unknown} value the limit provided through the `maxNestingDepth` option
	* @returns {number} a safe, non-negative integer limit
	*/
	function resolveMaxNestingDepth(value) {
		return Number.isSafeInteger(value) && value >= 0 ? value : exports.MAX_NESTING_DEPTH;
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/util/index.js
var require_util$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.MAX_NESTING_DEPTH = exports.resolveMaxNestingDepth = exports.stripComments = exports.ensureObject = exports.getProp = exports.unesc = void 0;
	var unesc_1 = require_unesc();
	Object.defineProperty(exports, "unesc", {
		enumerable: true,
		get: function() {
			return __importDefault(unesc_1).default;
		}
	});
	var getProp_1 = require_getProp();
	Object.defineProperty(exports, "getProp", {
		enumerable: true,
		get: function() {
			return __importDefault(getProp_1).default;
		}
	});
	var ensureObject_1 = require_ensureObject();
	Object.defineProperty(exports, "ensureObject", {
		enumerable: true,
		get: function() {
			return __importDefault(ensureObject_1).default;
		}
	});
	var stripComments_1 = require_stripComments();
	Object.defineProperty(exports, "stripComments", {
		enumerable: true,
		get: function() {
			return __importDefault(stripComments_1).default;
		}
	});
	var maxNestingDepth_1 = require_maxNestingDepth();
	Object.defineProperty(exports, "resolveMaxNestingDepth", {
		enumerable: true,
		get: function() {
			return __importDefault(maxNestingDepth_1).default;
		}
	});
	Object.defineProperty(exports, "MAX_NESTING_DEPTH", {
		enumerable: true,
		get: function() {
			return maxNestingDepth_1.MAX_NESTING_DEPTH;
		}
	});
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/node.js
var require_node = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	var util_1 = require_util$1();
	var cloneNode = function(obj, parent, depth) {
		if (depth === void 0) depth = 0;
		if (depth > util_1.MAX_NESTING_DEPTH) throw new Error("Cannot clone selector: nesting depth exceeds the maximum of ".concat(util_1.MAX_NESTING_DEPTH, "."));
		if (typeof obj !== "object" || obj === null) return obj;
		var cloned = new obj.constructor();
		for (var i in obj) {
			if (!obj.hasOwnProperty(i)) continue;
			var value = obj[i];
			if (i === "parent" && typeof value === "object") {
				if (parent) cloned[i] = parent;
			} else if (value instanceof Array) cloned[i] = value.map(function(j) {
				return cloneNode(j, cloned, depth + 1);
			});
			else cloned[i] = cloneNode(value, cloned, depth + 1);
		}
		return cloned;
	};
	exports.default = function() {
		function Node(opts) {
			if (opts === void 0) opts = {};
			Object.assign(this, opts);
			this.spaces = this.spaces || {};
			this.spaces.before = this.spaces.before || "";
			this.spaces.after = this.spaces.after || "";
		}
		Node.prototype.remove = function() {
			if (this.parent) this.parent.removeChild(this);
			this.parent = void 0;
			return this;
		};
		Node.prototype.replaceWith = function() {
			if (this.parent) {
				for (var index in arguments) this.parent.insertBefore(this, arguments[index]);
				this.remove();
			}
			return this;
		};
		Node.prototype.next = function() {
			return this.parent.at(this.parent.index(this) + 1);
		};
		Node.prototype.prev = function() {
			return this.parent.at(this.parent.index(this) - 1);
		};
		Node.prototype.clone = function(overrides) {
			if (overrides === void 0) overrides = {};
			var cloned = cloneNode(this);
			for (var name in overrides) cloned[name] = overrides[name];
			return cloned;
		};
		/**
		* Some non-standard syntax doesn't follow normal escaping rules for css.
		* This allows non standard syntax to be appended to an existing property
		* by specifying the escaped value. By specifying the escaped value,
		* illegal characters are allowed to be directly inserted into css output.
		* @param {string} name the property to set
		* @param {any} value the unescaped value of the property
		* @param {string} valueEscaped optional. the escaped value of the property.
		*/
		Node.prototype.appendToPropertyAndEscape = function(name, value, valueEscaped) {
			if (!this.raws) this.raws = {};
			var originalValue = this[name];
			var originalEscaped = this.raws[name];
			this[name] = originalValue + value;
			if (originalEscaped || valueEscaped !== value) this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
			else delete this.raws[name];
		};
		/**
		* Some non-standard syntax doesn't follow normal escaping rules for css.
		* This allows the escaped value to be specified directly, allowing illegal
		* characters to be directly inserted into css output.
		* @param {string} name the property to set
		* @param {any} value the unescaped value of the property
		* @param {string} valueEscaped the escaped value of the property.
		*/
		Node.prototype.setPropertyAndEscape = function(name, value, valueEscaped) {
			if (!this.raws) this.raws = {};
			this[name] = value;
			this.raws[name] = valueEscaped;
		};
		/**
		* When you want a value to passed through to CSS directly. This method
		* deletes the corresponding raw value causing the stringifier to fallback
		* to the unescaped value.
		* @param {string} name the property to set.
		* @param {any} value The value that is both escaped and unescaped.
		*/
		Node.prototype.setPropertyWithoutEscape = function(name, value) {
			this[name] = value;
			if (this.raws) delete this.raws[name];
		};
		/**
		*
		* @param {number} line The number (starting with 1)
		* @param {number} column The column number (starting with 1)
		*/
		Node.prototype.isAtPosition = function(line, column) {
			if (this.source && this.source.start && this.source.end) {
				if (this.source.start.line > line) return false;
				if (this.source.end.line < line) return false;
				if (this.source.start.line === line && this.source.start.column > column) return false;
				if (this.source.end.line === line && this.source.end.column < column) return false;
				return true;
			}
		};
		Node.prototype.stringifyProperty = function(name) {
			return this.raws && this.raws[name] || this[name];
		};
		Object.defineProperty(Node.prototype, "rawSpaceBefore", {
			get: function() {
				var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
				if (rawSpace === void 0) rawSpace = this.spaces && this.spaces.before;
				return rawSpace || "";
			},
			set: function(raw) {
				(0, util_1.ensureObject)(this, "raws", "spaces");
				this.raws.spaces.before = raw;
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Node.prototype, "rawSpaceAfter", {
			get: function() {
				var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
				if (rawSpace === void 0) rawSpace = this.spaces.after;
				return rawSpace || "";
			},
			set: function(raw) {
				(0, util_1.ensureObject)(this, "raws", "spaces");
				this.raws.spaces.after = raw;
			},
			enumerable: false,
			configurable: true
		});
		Node.prototype.valueToString = function() {
			return String(this.stringifyProperty("value"));
		};
		Node.prototype.toString = function() {
			return [
				this.rawSpaceBefore,
				this.valueToString(),
				this.rawSpaceAfter
			].join("");
		};
		Node.prototype._stringify = function() {
			return this.toString();
		};
		return Node;
	}();
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/types.js
var require_types = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.UNIVERSAL = exports.ATTRIBUTE = exports.CLASS = exports.COMBINATOR = exports.COMMENT = exports.ID = exports.NESTING = exports.PSEUDO = exports.ROOT = exports.SELECTOR = exports.STRING = exports.TAG = void 0;
	exports.TAG = "tag";
	exports.STRING = "string";
	exports.SELECTOR = "selector";
	exports.ROOT = "root";
	exports.PSEUDO = "pseudo";
	exports.NESTING = "nesting";
	exports.ID = "id";
	exports.COMMENT = "comment";
	exports.COMBINATOR = "combinator";
	exports.CLASS = "class";
	exports.ATTRIBUTE = "attribute";
	exports.UNIVERSAL = "universal";
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/container.js
var require_container = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
			enumerable: true,
			get: function() {
				return m[k];
			}
		};
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		o[k2] = m[k];
	}));
	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__importStar || (function() {
		var ownKeys = function(o) {
			ownKeys = Object.getOwnPropertyNames || function(o) {
				var ar = [];
				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
				return ar;
			};
			return ownKeys(o);
		};
		return function(mod) {
			if (mod && mod.__esModule) return mod;
			var result = {};
			if (mod != null) {
				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
			}
			__setModuleDefault(result, mod);
			return result;
		};
	})();
	var __values = exports && exports.__values || function(o) {
		var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
		if (m) return m.call(o);
		if (o && typeof o.length === "number") return { next: function() {
			if (o && i >= o.length) o = void 0;
			return {
				value: o && o[i++],
				done: !o
			};
		} };
		throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
	};
	var __read = exports && exports.__read || function(o, n) {
		var m = typeof Symbol === "function" && o[Symbol.iterator];
		if (!m) return o;
		var i = m.call(o), r, ar = [], e;
		try {
			while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
		} catch (error) {
			e = { error };
		} finally {
			try {
				if (r && !r.done && (m = i["return"])) m.call(i);
			} finally {
				if (e) throw e.error;
			}
		}
		return ar;
	};
	var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
		if (pack || arguments.length === 2) {
			for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
				if (!ar) ar = Array.prototype.slice.call(from, 0, i);
				ar[i] = from[i];
			}
		}
		return to.concat(ar || Array.prototype.slice.call(from));
	};
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var util_1 = require_util$1();
	var node_1 = __importDefault(require_node());
	var types = __importStar(require_types());
	exports.default = function(_super) {
		__extends(Container, _super);
		function Container(opts) {
			var _this = _super.call(this, opts) || this;
			if (!_this.nodes) _this.nodes = [];
			return _this;
		}
		Container.prototype.append = function(selector) {
			selector.parent = this;
			this.nodes.push(selector);
			return this;
		};
		Container.prototype.prepend = function(selector) {
			selector.parent = this;
			this.nodes.unshift(selector);
			for (var id in this.indexes) this.indexes[id]++;
			return this;
		};
		Container.prototype.at = function(index) {
			return this.nodes[index];
		};
		Container.prototype.index = function(child) {
			if (typeof child === "number") return child;
			return this.nodes.indexOf(child);
		};
		Object.defineProperty(Container.prototype, "first", {
			get: function() {
				return this.at(0);
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Container.prototype, "last", {
			get: function() {
				return this.at(this.length - 1);
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Container.prototype, "length", {
			get: function() {
				return this.nodes.length;
			},
			enumerable: false,
			configurable: true
		});
		Container.prototype.removeChild = function(child) {
			child = this.index(child);
			this.at(child).parent = void 0;
			this.nodes.splice(child, 1);
			var index;
			for (var id in this.indexes) {
				index = this.indexes[id];
				if (index >= child) this.indexes[id] = index - 1;
			}
			return this;
		};
		Container.prototype.removeAll = function() {
			var e_1, _a;
			try {
				for (var _b = __values(this.nodes), _c = _b.next(); !_c.done; _c = _b.next()) {
					var node = _c.value;
					node.parent = void 0;
				}
			} catch (e_1_1) {
				e_1 = { error: e_1_1 };
			} finally {
				try {
					if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
				} finally {
					if (e_1) throw e_1.error;
				}
			}
			this.nodes = [];
			return this;
		};
		Container.prototype.empty = function() {
			return this.removeAll();
		};
		Container.prototype.insertAfter = function(oldNode, newNode) {
			var _a;
			newNode.parent = this;
			var oldIndex = this.index(oldNode);
			var resetNode = [];
			for (var i = 2; i < arguments.length; i++) resetNode.push(arguments[i]);
			(_a = this.nodes).splice.apply(_a, __spreadArray([
				oldIndex + 1,
				0,
				newNode
			], __read(resetNode), false));
			newNode.parent = this;
			var index;
			for (var id in this.indexes) {
				index = this.indexes[id];
				if (oldIndex < index) this.indexes[id] = index + arguments.length - 1;
			}
			return this;
		};
		Container.prototype.insertBefore = function(oldNode, newNode) {
			var _a;
			newNode.parent = this;
			var oldIndex = this.index(oldNode);
			var resetNode = [];
			for (var i = 2; i < arguments.length; i++) resetNode.push(arguments[i]);
			(_a = this.nodes).splice.apply(_a, __spreadArray([
				oldIndex,
				0,
				newNode
			], __read(resetNode), false));
			newNode.parent = this;
			var index;
			for (var id in this.indexes) {
				index = this.indexes[id];
				if (index >= oldIndex) this.indexes[id] = index + arguments.length - 1;
			}
			return this;
		};
		Container.prototype._findChildAtPosition = function(line, col) {
			var found = void 0;
			this.each(function(node) {
				if (node.atPosition) {
					var foundChild = node.atPosition(line, col);
					if (foundChild) {
						found = foundChild;
						return false;
					}
				} else if (node.isAtPosition(line, col)) {
					found = node;
					return false;
				}
			});
			return found;
		};
		/**
		* Return the most specific node at the line and column number given.
		* The source location is based on the original parsed location, locations aren't
		* updated as selector nodes are mutated.
		*
		* Note that this location is relative to the location of the first character
		* of the selector, and not the location of the selector in the overall document
		* when used in conjunction with postcss.
		*
		* If not found, returns undefined.
		* @param {number} line The line number of the node to find. (1-based index)
		* @param {number} col  The column number of the node to find. (1-based index)
		*/
		Container.prototype.atPosition = function(line, col) {
			if (this.isAtPosition(line, col)) return this._findChildAtPosition(line, col) || this;
			else return;
		};
		Container.prototype._inferEndPosition = function() {
			if (this.last && this.last.source && this.last.source.end) {
				this.source = this.source || {};
				this.source.end = this.source.end || {};
				Object.assign(this.source.end, this.last.source.end);
			}
		};
		Container.prototype.each = function(callback) {
			if (!this.lastEach) this.lastEach = 0;
			if (!this.indexes) this.indexes = {};
			this.lastEach++;
			var id = this.lastEach;
			this.indexes[id] = 0;
			if (!this.length) return;
			var index, result;
			while (this.indexes[id] < this.length) {
				index = this.indexes[id];
				result = callback(this.at(index), index);
				if (result === false) break;
				this.indexes[id] += 1;
			}
			delete this.indexes[id];
			if (result === false) return false;
		};
		Container.prototype.walk = function(callback, depth) {
			if (depth === void 0) depth = 0;
			if (depth > util_1.MAX_NESTING_DEPTH) throw new Error("Cannot walk selector: nesting depth exceeds the maximum of ".concat(util_1.MAX_NESTING_DEPTH, "."));
			return this.each(function(node, i) {
				var result = callback(node, i);
				if (result !== false && node.length) result = node.walk(callback, depth + 1);
				if (result === false) return false;
			});
		};
		Container.prototype.walkAttributes = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.ATTRIBUTE) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkClasses = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.CLASS) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkCombinators = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.COMBINATOR) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkComments = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.COMMENT) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkIds = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.ID) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkNesting = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.NESTING) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkPseudos = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.PSEUDO) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkTags = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.TAG) return callback.call(_this, selector);
			});
		};
		Container.prototype.walkUniversals = function(callback) {
			var _this = this;
			return this.walk(function(selector) {
				if (selector.type === types.UNIVERSAL) return callback.call(_this, selector);
			});
		};
		Container.prototype.split = function(callback) {
			var _this = this;
			var current = [];
			return this.reduce(function(memo, node, index) {
				var split = callback.call(_this, node);
				current.push(node);
				if (split) {
					memo.push(current);
					current = [];
				} else if (index === _this.length - 1) memo.push(current);
				return memo;
			}, []);
		};
		Container.prototype.map = function(callback) {
			return this.nodes.map(callback);
		};
		Container.prototype.reduce = function(callback, memo) {
			return this.nodes.reduce(callback, memo);
		};
		Container.prototype.every = function(callback) {
			return this.nodes.every(callback);
		};
		Container.prototype.some = function(callback) {
			return this.nodes.some(callback);
		};
		Container.prototype.filter = function(callback) {
			return this.nodes.filter(callback);
		};
		Container.prototype.sort = function(callback) {
			return this.nodes.sort(callback);
		};
		Container.prototype.toString = function(options) {
			if (options === void 0) options = {};
			return this._stringify(options, 0, (0, util_1.resolveMaxNestingDepth)(options.maxNestingDepth));
		};
		Container.prototype._stringify = function(options, depth, max) {
			var _this = this;
			return this.map(function(child) {
				return _this._stringifyChild(child, options, depth, max);
			}).join("");
		};
		Container.prototype._stringifyChild = function(child, options, depth, max) {
			return typeof child._stringify === "function" ? child._stringify(options, depth, max) : String(child);
		};
		return Container;
	}(node_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/root.js
var require_root = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var container_1 = __importDefault(require_container());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Root, _super);
		function Root(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.ROOT;
			return _this;
		}
		Root.prototype._stringify = function(options, depth, max) {
			var _this = this;
			var str = this.reduce(function(memo, selector) {
				memo.push(_this._stringifyChild(selector, options, depth, max));
				return memo;
			}, []).join(",");
			return this.trailingComma ? str + "," : str;
		};
		Root.prototype.error = function(message, options) {
			if (this._error) return this._error(message, options);
			else return new Error(message);
		};
		Object.defineProperty(Root.prototype, "errorGenerator", {
			set: function(handler) {
				this._error = handler;
			},
			enumerable: false,
			configurable: true
		});
		return Root;
	}(container_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/selector.js
var require_selector = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var container_1 = __importDefault(require_container());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Selector, _super);
		function Selector(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.SELECTOR;
			return _this;
		}
		return Selector;
	}(container_1.default);
}));
//#endregion
//#region node_modules/.pnpm/cssesc@3.0.0/node_modules/cssesc/cssesc.js
/*! https://mths.be/cssesc v3.0.0 by @mathias */
var require_cssesc = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	var hasOwnProperty = {}.hasOwnProperty;
	var merge = function merge(options, defaults) {
		if (!options) return defaults;
		var result = {};
		for (var key in defaults) result[key] = hasOwnProperty.call(options, key) ? options[key] : defaults[key];
		return result;
	};
	var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
	var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
	var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
	var cssesc = function cssesc(string, options) {
		options = merge(options, cssesc.options);
		if (options.quotes != "single" && options.quotes != "double") options.quotes = "single";
		var quote = options.quotes == "double" ? "\"" : "'";
		var isIdentifier = options.isIdentifier;
		var firstChar = string.charAt(0);
		var output = "";
		var counter = 0;
		var length = string.length;
		while (counter < length) {
			var character = string.charAt(counter++);
			var codePoint = character.charCodeAt();
			var value = void 0;
			if (codePoint < 32 || codePoint > 126) {
				if (codePoint >= 55296 && codePoint <= 56319 && counter < length) {
					var extra = string.charCodeAt(counter++);
					if ((extra & 64512) == 56320) codePoint = ((codePoint & 1023) << 10) + (extra & 1023) + 65536;
					else counter--;
				}
				value = "\\" + codePoint.toString(16).toUpperCase() + " ";
			} else if (options.escapeEverything) {
				if (regexAnySingleEscape.test(character)) value = "\\" + character;
				else value = "\\" + codePoint.toString(16).toUpperCase() + " ";
			} else if (/[\t\n\f\r\x0B]/.test(character)) value = "\\" + codePoint.toString(16).toUpperCase() + " ";
			else if (character == "\\" || !isIdentifier && (character == "\"" && quote == character || character == "'" && quote == character) || isIdentifier && regexSingleEscape.test(character)) value = "\\" + character;
			else value = character;
			output += value;
		}
		if (isIdentifier) {
			if (/^-[-\d]/.test(output)) output = "\\-" + output.slice(1);
			else if (/\d/.test(firstChar)) output = "\\3" + firstChar + " " + output.slice(1);
		}
		output = output.replace(regexExcessiveSpaces, function($0, $1, $2) {
			if ($1 && $1.length % 2) return $0;
			return ($1 || "") + $2;
		});
		if (!isIdentifier && options.wrap) return quote + output + quote;
		return output;
	};
	cssesc.options = {
		"escapeEverything": false,
		"isIdentifier": false,
		"quotes": "single",
		"wrap": false
	};
	cssesc.version = "3.0.0";
	module.exports = cssesc;
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/className.js
var require_className = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var cssesc_1 = __importDefault(require_cssesc());
	var util_1 = require_util$1();
	var node_1 = __importDefault(require_node());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(ClassName, _super);
		function ClassName(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.CLASS;
			_this._constructed = true;
			return _this;
		}
		Object.defineProperty(ClassName.prototype, "value", {
			get: function() {
				return this._value;
			},
			set: function(v) {
				if (this._constructed) {
					var escaped = (0, cssesc_1.default)(v, { isIdentifier: true });
					if (escaped !== v) {
						(0, util_1.ensureObject)(this, "raws");
						this.raws.value = escaped;
					} else if (this.raws) delete this.raws.value;
				}
				this._value = v;
			},
			enumerable: false,
			configurable: true
		});
		ClassName.prototype.valueToString = function() {
			return "." + _super.prototype.valueToString.call(this);
		};
		return ClassName;
	}(node_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/comment.js
var require_comment = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var node_1 = __importDefault(require_node());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Comment, _super);
		function Comment(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.COMMENT;
			return _this;
		}
		return Comment;
	}(node_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/id.js
var require_id = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var node_1 = __importDefault(require_node());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(ID, _super);
		function ID(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.ID;
			return _this;
		}
		ID.prototype.valueToString = function() {
			return "#" + _super.prototype.valueToString.call(this);
		};
		return ID;
	}(node_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/namespace.js
var require_namespace = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var cssesc_1 = __importDefault(require_cssesc());
	var util_1 = require_util$1();
	exports.default = function(_super) {
		__extends(Namespace, _super);
		function Namespace() {
			return _super !== null && _super.apply(this, arguments) || this;
		}
		Object.defineProperty(Namespace.prototype, "namespace", {
			get: function() {
				return this._namespace;
			},
			set: function(namespace) {
				if (namespace === true || namespace === "*" || namespace === "&") {
					this._namespace = namespace;
					if (this.raws) delete this.raws.namespace;
					return;
				}
				var escaped = (0, cssesc_1.default)(namespace, { isIdentifier: true });
				this._namespace = namespace;
				if (escaped !== namespace) {
					(0, util_1.ensureObject)(this, "raws");
					this.raws.namespace = escaped;
				} else if (this.raws) delete this.raws.namespace;
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Namespace.prototype, "ns", {
			get: function() {
				return this._namespace;
			},
			set: function(namespace) {
				this.namespace = namespace;
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Namespace.prototype, "namespaceString", {
			get: function() {
				if (this.namespace) {
					var ns = this.stringifyProperty("namespace");
					if (ns === true) return "";
					else return ns;
				} else return "";
			},
			enumerable: false,
			configurable: true
		});
		Namespace.prototype.qualifiedName = function(value) {
			if (this.namespace) return "".concat(this.namespaceString, "|").concat(value);
			else return value;
		};
		Namespace.prototype.valueToString = function() {
			return this.qualifiedName(_super.prototype.valueToString.call(this));
		};
		return Namespace;
	}(__importDefault(require_node()).default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/tag.js
var require_tag = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var namespace_1 = __importDefault(require_namespace());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Tag, _super);
		function Tag(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.TAG;
			return _this;
		}
		return Tag;
	}(namespace_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/string.js
var require_string = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var node_1 = __importDefault(require_node());
	var types_1 = require_types();
	var String = function(_super) {
		__extends(String, _super);
		function String(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.STRING;
			return _this;
		}
		return String;
	}(node_1.default);
	exports.default = String;
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/pseudo.js
var require_pseudo = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var container_1 = __importDefault(require_container());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Pseudo, _super);
		function Pseudo(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.PSEUDO;
			return _this;
		}
		Pseudo.prototype._stringify = function(options, depth, max) {
			var _this = this;
			if (depth >= max) throw new Error("Cannot serialize selector: nesting depth exceeds the maximum of ".concat(max, "."));
			var params = this.length ? "(" + this.map(function(child) {
				return _this._stringifyChild(child, options, depth + 1, max);
			}).join(",") + ")" : "";
			return [
				this.rawSpaceBefore,
				this.stringifyProperty("value"),
				params,
				this.rawSpaceAfter
			].join("");
		};
		return Pseudo;
	}(container_1.default);
}));
//#endregion
//#region node_modules/.pnpm/util-deprecate@1.0.2/node_modules/util-deprecate/browser.js
var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	init__polyfill_node_global();
	/**
	* Module exports.
	*/
	module.exports = deprecate;
	/**
	* Mark that a method should not be used.
	* Returns a modified function which warns once by default.
	*
	* If `localStorage.noDeprecation = true` is set, then it is a no-op.
	*
	* If `localStorage.throwDeprecation = true` is set, then deprecated functions
	* will throw an Error when invoked.
	*
	* If `localStorage.traceDeprecation = true` is set, then deprecated functions
	* will invoke `console.trace()` instead of `console.error()`.
	*
	* @param {Function} fn - the function to deprecate
	* @param {String} msg - the string to print to the console when `fn` is invoked
	* @returns {Function} a new "deprecated" version of `fn`
	* @api public
	*/
	function deprecate(fn, msg) {
		if (config("noDeprecation")) return fn;
		var warned = false;
		function deprecated() {
			if (!warned) {
				if (config("throwDeprecation")) throw new Error(msg);
				else if (config("traceDeprecation")) console.trace(msg);
				else console.warn(msg);
				warned = true;
			}
			return fn.apply(this, arguments);
		}
		return deprecated;
	}
	/**
	* Checks `localStorage` for boolean values for the given `name`.
	*
	* @param {String} name
	* @returns {Boolean}
	* @api private
	*/
	function config(name) {
		try {
			if (!_polyfill_node_global_default.localStorage) return false;
		} catch (_) {
			return false;
		}
		var val = _polyfill_node_global_default.localStorage[name];
		if (null == val) return false;
		return String(val).toLowerCase() === "true";
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/attribute.js
var require_attribute = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	var _a;
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.unescapeValue = unescapeValue;
	var cssesc_1 = __importDefault(require_cssesc());
	var unesc_1 = __importDefault(require_unesc());
	var namespace_1 = __importDefault(require_namespace());
	var types_1 = require_types();
	var deprecate = require_browser();
	var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
	var warnOfDeprecatedValueAssignment = deprecate(function() {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead.");
	var warnOfDeprecatedQuotedAssignment = deprecate(function() {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
	var warnOfDeprecatedConstructor = deprecate(function() {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
	function unescapeValue(value) {
		var deprecatedUsage = false;
		var quoteMark = null;
		var unescaped = value;
		var m = unescaped.match(WRAPPED_IN_QUOTES);
		if (m) {
			quoteMark = m[1];
			unescaped = m[2];
		}
		unescaped = (0, unesc_1.default)(unescaped);
		if (unescaped !== value) deprecatedUsage = true;
		return {
			deprecatedUsage,
			unescaped,
			quoteMark
		};
	}
	function handleDeprecatedContructorOpts(opts) {
		if (opts.quoteMark !== void 0) return opts;
		if (opts.value === void 0) return opts;
		warnOfDeprecatedConstructor();
		var _a = unescapeValue(opts.value), quoteMark = _a.quoteMark, unescaped = _a.unescaped;
		if (!opts.raws) opts.raws = {};
		if (opts.raws.value === void 0) opts.raws.value = opts.value;
		opts.value = unescaped;
		opts.quoteMark = quoteMark;
		return opts;
	}
	exports.default = function(_super) {
		__extends(Attribute, _super);
		function Attribute(opts) {
			if (opts === void 0) opts = {};
			var _this = _super.call(this, handleDeprecatedContructorOpts(opts)) || this;
			_this.type = types_1.ATTRIBUTE;
			_this.raws = _this.raws || {};
			Object.defineProperty(_this.raws, "unquoted", {
				get: deprecate(function() {
					return _this.value;
				}, "attr.raws.unquoted is deprecated. Call attr.value instead."),
				set: deprecate(function() {
					return _this.value;
				}, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
			});
			_this._constructed = true;
			return _this;
		}
		/**
		* Returns the Attribute's value quoted such that it would be legal to use
		* in the value of a css file. The original value's quotation setting
		* used for stringification is left unchanged. See `setValue(value, options)`
		* if you want to control the quote settings of a new value for the attribute.
		*
		* You can also change the quotation used for the current value by setting quoteMark.
		*
		* Options:
		*   * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
		*     option is not set, the original value for quoteMark will be used. If
		*     indeterminate, a double quote is used. The legal values are:
		*     * `null` - the value will be unquoted and characters will be escaped as necessary.
		*     * `'` - the value will be quoted with a single quote and single quotes are escaped.
		*     * `"` - the value will be quoted with a double quote and double quotes are escaped.
		*   * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
		*     over the quoteMark option value.
		*   * smart {boolean} - if true, will select a quote mark based on the value
		*     and the other options specified here. See the `smartQuoteMark()`
		*     method.
		**/
		Attribute.prototype.getQuotedValue = function(options) {
			if (options === void 0) options = {};
			var cssescopts = CSSESC_QUOTE_OPTIONS[this._determineQuoteMark(options)];
			return (0, cssesc_1.default)(this._value, cssescopts);
		};
		Attribute.prototype._determineQuoteMark = function(options) {
			return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
		};
		/**
		* Set the unescaped value with the specified quotation options. The value
		* provided must not include any wrapping quote marks -- those quotes will
		* be interpreted as part of the value and escaped accordingly.
		*/
		Attribute.prototype.setValue = function(value, options) {
			if (options === void 0) options = {};
			this._value = value;
			this._quoteMark = this._determineQuoteMark(options);
			this._syncRawValue();
		};
		/**
		* Intelligently select a quoteMark value based on the value's contents. If
		* the value is a legal CSS ident, it will not be quoted. Otherwise a quote
		* mark will be picked that minimizes the number of escapes.
		*
		* If there's no clear winner, the quote mark from these options is used,
		* then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
		* true). If the quoteMark is unspecified, a double quote is used.
		*
		* @param options This takes the quoteMark and preferCurrentQuoteMark options
		* from the quoteValue method.
		*/
		Attribute.prototype.smartQuoteMark = function(options) {
			var v = this.value;
			var numSingleQuotes = v.replace(/[^']/g, "").length;
			var numDoubleQuotes = v.replace(/[^"]/g, "").length;
			if (numSingleQuotes + numDoubleQuotes === 0) {
				var escaped = (0, cssesc_1.default)(v, { isIdentifier: true });
				if (escaped === v) return Attribute.NO_QUOTE;
				else {
					var pref = this.preferredQuoteMark(options);
					if (pref === Attribute.NO_QUOTE) {
						var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
						var opts = CSSESC_QUOTE_OPTIONS[quote];
						if ((0, cssesc_1.default)(v, opts).length < escaped.length) return quote;
					}
					return pref;
				}
			} else if (numDoubleQuotes === numSingleQuotes) return this.preferredQuoteMark(options);
			else if (numDoubleQuotes < numSingleQuotes) return Attribute.DOUBLE_QUOTE;
			else return Attribute.SINGLE_QUOTE;
		};
		/**
		* Selects the preferred quote mark based on the options and the current quote mark value.
		* If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
		* instead.
		*/
		Attribute.prototype.preferredQuoteMark = function(options) {
			var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
			if (quoteMark === void 0) quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
			if (quoteMark === void 0) quoteMark = Attribute.DOUBLE_QUOTE;
			return quoteMark;
		};
		Object.defineProperty(Attribute.prototype, "quoted", {
			get: function() {
				var qm = this.quoteMark;
				return qm === "'" || qm === "\"";
			},
			set: function(value) {
				warnOfDeprecatedQuotedAssignment();
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Attribute.prototype, "quoteMark", {
			/**
			* returns a single (`'`) or double (`"`) quote character if the value is quoted.
			* returns `null` if the value is not quoted.
			* returns `undefined` if the quotation state is unknown (this can happen when
			* the attribute is constructed without specifying a quote mark.)
			*/
			get: function() {
				return this._quoteMark;
			},
			/**
			* Set the quote mark to be used by this attribute's value.
			* If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
			* value is updated accordingly.
			*
			* @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
			*/
			set: function(quoteMark) {
				if (!this._constructed) {
					this._quoteMark = quoteMark;
					return;
				}
				if (this._quoteMark !== quoteMark) {
					this._quoteMark = quoteMark;
					this._syncRawValue();
				}
			},
			enumerable: false,
			configurable: true
		});
		Attribute.prototype._syncRawValue = function() {
			var rawValue = (0, cssesc_1.default)(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
			if (rawValue === this._value) {
				if (this.raws) delete this.raws.value;
			} else this.raws.value = rawValue;
		};
		Object.defineProperty(Attribute.prototype, "qualifiedAttribute", {
			get: function() {
				return this.qualifiedName(this.raws.attribute || this.attribute);
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Attribute.prototype, "insensitiveFlag", {
			get: function() {
				return this.insensitive ? "i" : "";
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Attribute.prototype, "value", {
			get: function() {
				return this._value;
			},
			/**
			* Before 3.0, the value had to be set to an escaped value including any wrapped
			* quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
			* is unescaped during parsing and any quote marks are removed.
			*
			* Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
			* a deprecation warning is raised when the new value contains any characters that would
			* require escaping (including if it contains wrapped quotes).
			*
			* Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
			* how the new value is quoted.
			*/
			set: function(v) {
				if (this._constructed) {
					var _a = unescapeValue(v), deprecatedUsage = _a.deprecatedUsage, unescaped = _a.unescaped, quoteMark = _a.quoteMark;
					if (deprecatedUsage) warnOfDeprecatedValueAssignment();
					if (unescaped === this._value && quoteMark === this._quoteMark) return;
					this._value = unescaped;
					this._quoteMark = quoteMark;
					this._syncRawValue();
				} else this._value = v;
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Attribute.prototype, "insensitive", {
			get: function() {
				return this._insensitive;
			},
			/**
			* Set the case insensitive flag.
			* If the case insensitive flag changes, the raw (escaped) value at `attr.raws.insensitiveFlag`
			* of the attribute is updated accordingly.
			*
			* @param {true | false} insensitive true if the attribute should match case-insensitively.
			*/
			set: function(insensitive) {
				if (!insensitive) {
					this._insensitive = false;
					if (this.raws && (this.raws.insensitiveFlag === "I" || this.raws.insensitiveFlag === "i")) this.raws.insensitiveFlag = void 0;
				}
				this._insensitive = insensitive;
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Attribute.prototype, "attribute", {
			get: function() {
				return this._attribute;
			},
			set: function(name) {
				this._handleEscapes("attribute", name);
				this._attribute = name;
			},
			enumerable: false,
			configurable: true
		});
		Attribute.prototype._handleEscapes = function(prop, value) {
			if (this._constructed) {
				var escaped = (0, cssesc_1.default)(value, { isIdentifier: true });
				if (escaped !== value) this.raws[prop] = escaped;
				else delete this.raws[prop];
			}
		};
		Attribute.prototype._spacesFor = function(name) {
			var attrSpaces = {
				before: "",
				after: ""
			};
			var spaces = this.spaces[name] || {};
			var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
			return Object.assign(attrSpaces, spaces, rawSpaces);
		};
		Attribute.prototype._stringFor = function(name, spaceName, concat) {
			if (spaceName === void 0) spaceName = name;
			if (concat === void 0) concat = defaultAttrConcat;
			var attrSpaces = this._spacesFor(spaceName);
			return concat(this.stringifyProperty(name), attrSpaces);
		};
		/**
		* returns the offset of the attribute part specified relative to the
		* start of the node of the output string.
		*
		* * "ns" - alias for "namespace"
		* * "namespace" - the namespace if it exists.
		* * "attribute" - the attribute name
		* * "attributeNS" - the start of the attribute or its namespace
		* * "operator" - the match operator of the attribute
		* * "value" - The value (string or identifier)
		* * "insensitive" - the case insensitivity flag;
		* @param part One of the possible values inside an attribute.
		* @returns -1 if the name is invalid or the value doesn't exist in this attribute.
		*/
		Attribute.prototype.offsetOf = function(name) {
			var count = 1;
			var attributeSpaces = this._spacesFor("attribute");
			count += attributeSpaces.before.length;
			if (name === "namespace" || name === "ns") return this.namespace ? count : -1;
			if (name === "attributeNS") return count;
			count += this.namespaceString.length;
			if (this.namespace) count += 1;
			if (name === "attribute") return count;
			count += this.stringifyProperty("attribute").length;
			count += attributeSpaces.after.length;
			var operatorSpaces = this._spacesFor("operator");
			count += operatorSpaces.before.length;
			var operator = this.stringifyProperty("operator");
			if (name === "operator") return operator ? count : -1;
			count += operator.length;
			count += operatorSpaces.after.length;
			var valueSpaces = this._spacesFor("value");
			count += valueSpaces.before.length;
			var value = this.stringifyProperty("value");
			if (name === "value") return value ? count : -1;
			count += value.length;
			count += valueSpaces.after.length;
			var insensitiveSpaces = this._spacesFor("insensitive");
			count += insensitiveSpaces.before.length;
			if (name === "insensitive") return this.insensitive ? count : -1;
			return -1;
		};
		Attribute.prototype.toString = function() {
			var _this = this;
			var selector = [this.rawSpaceBefore, "["];
			selector.push(this._stringFor("qualifiedAttribute", "attribute"));
			if (this.operator && (this.value || this.value === "")) {
				selector.push(this._stringFor("operator"));
				selector.push(this._stringFor("value"));
				selector.push(this._stringFor("insensitiveFlag", "insensitive", function(attrValue, attrSpaces) {
					if (attrValue.length > 0 && !_this.quoted && attrSpaces.before.length === 0 && !(_this.spaces.value && _this.spaces.value.after)) attrSpaces.before = " ";
					return defaultAttrConcat(attrValue, attrSpaces);
				}));
			}
			selector.push("]");
			selector.push(this.rawSpaceAfter);
			return selector.join("");
		};
		Attribute.NO_QUOTE = null;
		Attribute.SINGLE_QUOTE = "'";
		Attribute.DOUBLE_QUOTE = "\"";
		return Attribute;
	}(namespace_1.default);
	var CSSESC_QUOTE_OPTIONS = (_a = {
		"'": {
			quotes: "single",
			wrap: true
		},
		"\"": {
			quotes: "double",
			wrap: true
		}
	}, _a[null] = { isIdentifier: true }, _a);
	function defaultAttrConcat(attrValue, attrSpaces) {
		return "".concat(attrSpaces.before).concat(attrValue).concat(attrSpaces.after);
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/universal.js
var require_universal = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var namespace_1 = __importDefault(require_namespace());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Universal, _super);
		function Universal(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.UNIVERSAL;
			_this.value = "*";
			return _this;
		}
		return Universal;
	}(namespace_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/combinator.js
var require_combinator = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var node_1 = __importDefault(require_node());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Combinator, _super);
		function Combinator(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.COMBINATOR;
			return _this;
		}
		return Combinator;
	}(node_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/nesting.js
var require_nesting = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __extends = exports && exports.__extends || (function() {
		var extendStatics = function(d, b) {
			extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
				d.__proto__ = b;
			} || function(d, b) {
				for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
			};
			return extendStatics(d, b);
		};
		return function(d, b) {
			if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
			extendStatics(d, b);
			function __() {
				this.constructor = d;
			}
			d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		};
	})();
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var node_1 = __importDefault(require_node());
	var types_1 = require_types();
	exports.default = function(_super) {
		__extends(Nesting, _super);
		function Nesting(opts) {
			var _this = _super.call(this, opts) || this;
			_this.type = types_1.NESTING;
			_this.value = "&";
			return _this;
		}
		return Nesting;
	}(node_1.default);
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/sortAscending.js
var require_sortAscending = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.default = sortAscending;
	function sortAscending(list) {
		return list.sort(function(a, b) {
			return a - b;
		});
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/tokenTypes.js
var require_tokenTypes = /* @__PURE__ */ __commonJSMin(((exports) => {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.combinator = exports.word = exports.comment = exports.str = exports.tab = exports.newline = exports.feed = exports.cr = exports.backslash = exports.bang = exports.slash = exports.doubleQuote = exports.singleQuote = exports.space = exports.greaterThan = exports.pipe = exports.equals = exports.plus = exports.caret = exports.tilde = exports.dollar = exports.closeSquare = exports.openSquare = exports.closeParenthesis = exports.openParenthesis = exports.semicolon = exports.colon = exports.comma = exports.at = exports.asterisk = exports.ampersand = void 0;
	exports.ampersand = 38;
	exports.asterisk = 42;
	exports.at = 64;
	exports.comma = 44;
	exports.colon = 58;
	exports.semicolon = 59;
	exports.openParenthesis = 40;
	exports.closeParenthesis = 41;
	exports.openSquare = 91;
	exports.closeSquare = 93;
	exports.dollar = 36;
	exports.tilde = 126;
	exports.caret = 94;
	exports.plus = 43;
	exports.equals = 61;
	exports.pipe = 124;
	exports.greaterThan = 62;
	exports.space = 32;
	exports.singleQuote = 39;
	exports.doubleQuote = 34;
	exports.slash = 47;
	exports.bang = 33;
	exports.backslash = 92;
	exports.cr = 13;
	exports.feed = 12;
	exports.newline = 10;
	exports.tab = 9;
	exports.str = exports.singleQuote;
	exports.comment = -1;
	exports.word = -2;
	exports.combinator = -3;
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/tokenize.js
var require_tokenize = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
			enumerable: true,
			get: function() {
				return m[k];
			}
		};
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		o[k2] = m[k];
	}));
	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__importStar || (function() {
		var ownKeys = function(o) {
			ownKeys = Object.getOwnPropertyNames || function(o) {
				var ar = [];
				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
				return ar;
			};
			return ownKeys(o);
		};
		return function(mod) {
			if (mod && mod.__esModule) return mod;
			var result = {};
			if (mod != null) {
				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
			}
			__setModuleDefault(result, mod);
			return result;
		};
	})();
	var _a;
	var _b;
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.FIELDS = void 0;
	exports.default = tokenize;
	var t = __importStar(require_tokenTypes());
	var unescapable = (_a = {}, _a[t.tab] = true, _a[t.newline] = true, _a[t.cr] = true, _a[t.feed] = true, _a);
	var wordDelimiters = (_b = {}, _b[t.space] = true, _b[t.tab] = true, _b[t.newline] = true, _b[t.cr] = true, _b[t.feed] = true, _b[t.ampersand] = true, _b[t.asterisk] = true, _b[t.bang] = true, _b[t.comma] = true, _b[t.colon] = true, _b[t.semicolon] = true, _b[t.openParenthesis] = true, _b[t.closeParenthesis] = true, _b[t.openSquare] = true, _b[t.closeSquare] = true, _b[t.singleQuote] = true, _b[t.doubleQuote] = true, _b[t.plus] = true, _b[t.pipe] = true, _b[t.tilde] = true, _b[t.greaterThan] = true, _b[t.equals] = true, _b[t.dollar] = true, _b[t.caret] = true, _b[t.slash] = true, _b);
	var hex = {};
	var hexChars = "0123456789abcdefABCDEF";
	for (var i = 0; i < hexChars.length; i++) hex[hexChars.charCodeAt(i)] = true;
	/**
	*  Returns the last index of the bar css word
	* @param {string} css The string in which the word begins
	* @param {number} start The index into the string where word's first letter occurs
	*/
	function consumeWord(css, start) {
		var next = start;
		var code;
		do {
			code = css.charCodeAt(next);
			if (wordDelimiters[code]) return next - 1;
			else if (code === t.backslash) next = consumeEscape(css, next) + 1;
			else next++;
		} while (next < css.length);
		return next - 1;
	}
	/**
	*  Returns the last index of the escape sequence
	* @param {string} css The string in which the sequence begins
	* @param {number} start The index into the string where escape character (`\`) occurs.
	*/
	function consumeEscape(css, start) {
		var next = start;
		var code = css.charCodeAt(next + 1);
		if (unescapable[code]) {} else if (hex[code]) {
			var hexDigits = 0;
			do {
				next++;
				hexDigits++;
				code = css.charCodeAt(next + 1);
			} while (hex[code] && hexDigits < 6);
			if (hexDigits < 6 && code === t.space) next++;
		} else next++;
		return next;
	}
	exports.FIELDS = {
		TYPE: 0,
		START_LINE: 1,
		START_COL: 2,
		END_LINE: 3,
		END_COL: 4,
		START_POS: 5,
		END_POS: 6
	};
	function tokenize(input) {
		var tokens = [];
		var css = input.css.valueOf();
		var length = css.length;
		var offset = -1;
		var line = 1;
		var start = 0;
		var end = 0;
		var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
		function unclosed(what, fix) {
			if (input.safe) {
				css += fix;
				next = css.length - 1;
			} else throw input.error("Unclosed " + what, line, start - offset, start);
		}
		while (start < length) {
			code = css.charCodeAt(start);
			if (code === t.newline) {
				offset = start;
				line += 1;
			}
			switch (code) {
				case t.space:
				case t.tab:
				case t.newline:
				case t.cr:
				case t.feed:
					next = start;
					do {
						next += 1;
						code = css.charCodeAt(next);
						if (code === t.newline) {
							offset = next;
							line += 1;
						}
					} while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
					tokenType = t.space;
					endLine = line;
					endColumn = next - offset - 1;
					end = next;
					break;
				case t.plus:
				case t.greaterThan:
				case t.tilde:
				case t.pipe:
					next = start;
					do {
						next += 1;
						code = css.charCodeAt(next);
					} while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
					tokenType = t.combinator;
					endLine = line;
					endColumn = start - offset;
					end = next;
					break;
				case t.asterisk:
				case t.ampersand:
				case t.bang:
				case t.comma:
				case t.equals:
				case t.dollar:
				case t.caret:
				case t.openSquare:
				case t.closeSquare:
				case t.colon:
				case t.semicolon:
				case t.openParenthesis:
				case t.closeParenthesis:
					next = start;
					tokenType = code;
					endLine = line;
					endColumn = start - offset;
					end = next + 1;
					break;
				case t.singleQuote:
				case t.doubleQuote:
					quote = code === t.singleQuote ? "'" : "\"";
					next = start;
					do {
						escaped = false;
						next = css.indexOf(quote, next + 1);
						if (next === -1) unclosed("quote", quote);
						escapePos = next;
						while (css.charCodeAt(escapePos - 1) === t.backslash) {
							escapePos -= 1;
							escaped = !escaped;
						}
					} while (escaped);
					tokenType = t.str;
					endLine = line;
					endColumn = start - offset;
					end = next + 1;
					break;
				default:
					if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
						next = css.indexOf("*/", start + 2) + 1;
						if (next === 0) unclosed("comment", "*/");
						content = css.slice(start, next + 1);
						lines = content.split("\n");
						last = lines.length - 1;
						if (last > 0) {
							nextLine = line + last;
							nextOffset = next - lines[last].length;
						} else {
							nextLine = line;
							nextOffset = offset;
						}
						tokenType = t.comment;
						line = nextLine;
						endLine = nextLine;
						endColumn = next - nextOffset;
					} else if (code === t.slash) {
						next = start;
						tokenType = code;
						endLine = line;
						endColumn = start - offset;
						end = next + 1;
					} else {
						next = consumeWord(css, start);
						tokenType = t.word;
						endLine = line;
						endColumn = next - offset;
					}
					end = next + 1;
			}
			tokens.push([
				tokenType,
				line,
				start - offset,
				endLine,
				endColumn,
				start,
				end
			]);
			if (nextOffset) {
				offset = nextOffset;
				nextOffset = null;
			}
			start = end;
		}
		return tokens;
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/parser.js
var require_parser = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __assign = exports && exports.__assign || function() {
		__assign = Object.assign || function(t) {
			for (var s, i = 1, n = arguments.length; i < n; i++) {
				s = arguments[i];
				for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
			}
			return t;
		};
		return __assign.apply(this, arguments);
	};
	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
			enumerable: true,
			get: function() {
				return m[k];
			}
		};
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		o[k2] = m[k];
	}));
	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__importStar || (function() {
		var ownKeys = function(o) {
			ownKeys = Object.getOwnPropertyNames || function(o) {
				var ar = [];
				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
				return ar;
			};
			return ownKeys(o);
		};
		return function(mod) {
			if (mod && mod.__esModule) return mod;
			var result = {};
			if (mod != null) {
				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
			}
			__setModuleDefault(result, mod);
			return result;
		};
	})();
	var __read = exports && exports.__read || function(o, n) {
		var m = typeof Symbol === "function" && o[Symbol.iterator];
		if (!m) return o;
		var i = m.call(o), r, ar = [], e;
		try {
			while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
		} catch (error) {
			e = { error };
		} finally {
			try {
				if (r && !r.done && (m = i["return"])) m.call(i);
			} finally {
				if (e) throw e.error;
			}
		}
		return ar;
	};
	var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
		if (pack || arguments.length === 2) {
			for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
				if (!ar) ar = Array.prototype.slice.call(from, 0, i);
				ar[i] = from[i];
			}
		}
		return to.concat(ar || Array.prototype.slice.call(from));
	};
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	var _a;
	var _b;
	Object.defineProperty(exports, "__esModule", { value: true });
	var root_1 = __importDefault(require_root());
	var selector_1 = __importDefault(require_selector());
	var className_1 = __importDefault(require_className());
	var comment_1 = __importDefault(require_comment());
	var id_1 = __importDefault(require_id());
	var tag_1 = __importDefault(require_tag());
	var string_1 = __importDefault(require_string());
	var pseudo_1 = __importDefault(require_pseudo());
	var attribute_1 = __importStar(require_attribute());
	var universal_1 = __importDefault(require_universal());
	var combinator_1 = __importDefault(require_combinator());
	var nesting_1 = __importDefault(require_nesting());
	var sortAscending_1 = __importDefault(require_sortAscending());
	var tokenize_1 = __importStar(require_tokenize());
	var tokens = __importStar(require_tokenTypes());
	var types = __importStar(require_types());
	var util_1 = require_util$1();
	var WHITESPACE_TOKENS = (_a = {}, _a[tokens.space] = true, _a[tokens.cr] = true, _a[tokens.feed] = true, _a[tokens.newline] = true, _a[tokens.tab] = true, _a);
	var WHITESPACE_EQUIV_TOKENS = __assign(__assign({}, WHITESPACE_TOKENS), (_b = {}, _b[tokens.comment] = true, _b));
	function tokenStart(token) {
		return {
			line: token[tokenize_1.FIELDS.START_LINE],
			column: token[tokenize_1.FIELDS.START_COL]
		};
	}
	function tokenEnd(token) {
		return {
			line: token[tokenize_1.FIELDS.END_LINE],
			column: token[tokenize_1.FIELDS.END_COL]
		};
	}
	function getSource(startLine, startColumn, endLine, endColumn) {
		return {
			start: {
				line: startLine,
				column: startColumn
			},
			end: {
				line: endLine,
				column: endColumn
			}
		};
	}
	function getTokenSource(token) {
		return getSource(token[tokenize_1.FIELDS.START_LINE], token[tokenize_1.FIELDS.START_COL], token[tokenize_1.FIELDS.END_LINE], token[tokenize_1.FIELDS.END_COL]);
	}
	function getTokenSourceSpan(startToken, endToken) {
		if (!startToken) return;
		return getSource(startToken[tokenize_1.FIELDS.START_LINE], startToken[tokenize_1.FIELDS.START_COL], endToken[tokenize_1.FIELDS.END_LINE], endToken[tokenize_1.FIELDS.END_COL]);
	}
	function unescapeProp(node, prop) {
		var value = node[prop];
		if (typeof value !== "string") return;
		if (value.indexOf("\\") !== -1) {
			(0, util_1.ensureObject)(node, "raws");
			node[prop] = (0, util_1.unesc)(value);
			if (node.raws[prop] === void 0) node.raws[prop] = value;
		}
		return node;
	}
	function indexesOf(array, item) {
		var i = -1;
		var indexes = [];
		while ((i = array.indexOf(item, i + 1)) !== -1) indexes.push(i);
		return indexes;
	}
	function uniqs() {
		return Array.from(new Set(Array.prototype.concat.apply([], arguments)));
	}
	exports.default = function() {
		function Parser(rule, options) {
			if (options === void 0) options = {};
			this.rule = rule;
			this.options = Object.assign({
				lossy: false,
				safe: false
			}, options);
			this.position = 0;
			this.nestingDepth = 0;
			this.maxNestingDepth = (0, util_1.resolveMaxNestingDepth)(this.options.maxNestingDepth);
			this.css = typeof this.rule === "string" ? this.rule : this.rule.selector;
			this.tokens = (0, tokenize_1.default)({
				css: this.css,
				error: this._errorGenerator(),
				safe: this.options.safe
			});
			var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
			this.root = new root_1.default({ source: rootSource });
			this.root.errorGenerator = this._errorGenerator();
			var selector = new selector_1.default({
				source: { start: {
					line: 1,
					column: 1
				} },
				sourceIndex: 0
			});
			this.root.append(selector);
			this.current = selector;
			this.loop();
		}
		Parser.prototype._errorGenerator = function() {
			var _this = this;
			return function(message, errorOptions) {
				if (typeof _this.rule === "string") return new Error(message);
				return _this.rule.error(message, errorOptions);
			};
		};
		Parser.prototype.attribute = function() {
			var attr = [];
			var startingToken = this.currToken;
			this.position++;
			while (this.position < this.tokens.length && this.currToken[tokenize_1.FIELDS.TYPE] !== tokens.closeSquare) {
				attr.push(this.currToken);
				this.position++;
			}
			if (!this.currToken) return this.expected("closing square bracket", startingToken[tokenize_1.FIELDS.START_POS]);
			if (this.currToken[tokenize_1.FIELDS.TYPE] !== tokens.closeSquare) return this.expected("closing square bracket", this.currToken[tokenize_1.FIELDS.START_POS]);
			var len = attr.length;
			var node = {
				source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
				sourceIndex: startingToken[tokenize_1.FIELDS.START_POS]
			};
			if (len === 1 && !~[tokens.word].indexOf(attr[0][tokenize_1.FIELDS.TYPE])) return this.expected("attribute", attr[0][tokenize_1.FIELDS.START_POS]);
			var pos = 0;
			var spaceBefore = "";
			var commentBefore = "";
			var lastAdded = null;
			var spaceAfterMeaningfulToken = false;
			while (pos < len) {
				var token = attr[pos];
				var content = this.content(token);
				var next = attr[pos + 1];
				switch (token[tokenize_1.FIELDS.TYPE]) {
					case tokens.space:
						spaceAfterMeaningfulToken = true;
						if (this.options.lossy) break;
						if (lastAdded) {
							(0, util_1.ensureObject)(node, "spaces", lastAdded);
							var prevContent = node.spaces[lastAdded].after || "";
							node.spaces[lastAdded].after = prevContent + content;
							var existingComment = (0, util_1.getProp)(node, "raws", "spaces", lastAdded, "after") || null;
							if (existingComment) node.raws.spaces[lastAdded].after = existingComment + content;
						} else {
							spaceBefore = spaceBefore + content;
							commentBefore = commentBefore + content;
						}
						break;
					case tokens.asterisk:
						if (next[tokenize_1.FIELDS.TYPE] === tokens.equals) {
							node.operator = content;
							lastAdded = "operator";
						} else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
							if (spaceBefore) {
								(0, util_1.ensureObject)(node, "spaces", "attribute");
								node.spaces.attribute.before = spaceBefore;
								spaceBefore = "";
							}
							if (commentBefore) {
								(0, util_1.ensureObject)(node, "raws", "spaces", "attribute");
								node.raws.spaces.attribute.before = commentBefore;
								commentBefore = "";
							}
							node.namespace = (node.namespace || "") + content;
							var rawValue = (0, util_1.getProp)(node, "raws", "namespace") || null;
							if (rawValue) node.raws.namespace += content;
							lastAdded = "namespace";
						}
						spaceAfterMeaningfulToken = false;
						break;
					case tokens.dollar: if (lastAdded === "value") {
						var oldRawValue = (0, util_1.getProp)(node, "raws", "value");
						node.value += "$";
						if (oldRawValue) node.raws.value = oldRawValue + "$";
						break;
					}
					case tokens.caret:
						if (next[tokenize_1.FIELDS.TYPE] === tokens.equals) {
							node.operator = content;
							lastAdded = "operator";
						}
						spaceAfterMeaningfulToken = false;
						break;
					case tokens.combinator:
						if (content === "~" && next[tokenize_1.FIELDS.TYPE] === tokens.equals) {
							node.operator = content;
							lastAdded = "operator";
						}
						if (content !== "|") {
							spaceAfterMeaningfulToken = false;
							break;
						}
						if (next[tokenize_1.FIELDS.TYPE] === tokens.equals) {
							node.operator = content;
							lastAdded = "operator";
						} else if (!node.namespace && !node.attribute) node.namespace = true;
						spaceAfterMeaningfulToken = false;
						break;
					case tokens.word:
						if (next && this.content(next) === "|" && attr[pos + 2] && attr[pos + 2][tokenize_1.FIELDS.TYPE] !== tokens.equals && !node.operator && !node.namespace) {
							node.namespace = content;
							lastAdded = "namespace";
						} else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
							if (spaceBefore) {
								(0, util_1.ensureObject)(node, "spaces", "attribute");
								node.spaces.attribute.before = spaceBefore;
								spaceBefore = "";
							}
							if (commentBefore) {
								(0, util_1.ensureObject)(node, "raws", "spaces", "attribute");
								node.raws.spaces.attribute.before = commentBefore;
								commentBefore = "";
							}
							node.attribute = (node.attribute || "") + content;
							var rawValue = (0, util_1.getProp)(node, "raws", "attribute") || null;
							if (rawValue) node.raws.attribute += content;
							lastAdded = "attribute";
						} else if (!node.value && node.value !== "" || lastAdded === "value" && !(spaceAfterMeaningfulToken || node.quoteMark)) {
							var unescaped_1 = (0, util_1.unesc)(content);
							var oldRawValue = (0, util_1.getProp)(node, "raws", "value") || "";
							var oldValue = node.value || "";
							node.value = oldValue + unescaped_1;
							node.quoteMark = null;
							if (unescaped_1 !== content || oldRawValue) {
								(0, util_1.ensureObject)(node, "raws");
								node.raws.value = (oldRawValue || oldValue) + content;
							}
							lastAdded = "value";
						} else {
							var insensitive = content === "i" || content === "I";
							if ((node.value || node.value === "") && (node.quoteMark || spaceAfterMeaningfulToken)) {
								node.insensitive = insensitive;
								if (!insensitive || content === "I") {
									(0, util_1.ensureObject)(node, "raws");
									node.raws.insensitiveFlag = content;
								}
								lastAdded = "insensitive";
								if (spaceBefore) {
									(0, util_1.ensureObject)(node, "spaces", "insensitive");
									node.spaces.insensitive.before = spaceBefore;
									spaceBefore = "";
								}
								if (commentBefore) {
									(0, util_1.ensureObject)(node, "raws", "spaces", "insensitive");
									node.raws.spaces.insensitive.before = commentBefore;
									commentBefore = "";
								}
							} else if (node.value || node.value === "") {
								lastAdded = "value";
								node.value += content;
								if (node.raws.value) node.raws.value += content;
							}
						}
						spaceAfterMeaningfulToken = false;
						break;
					case tokens.str:
						if (!node.attribute || !node.operator) return this.error("Expected an attribute followed by an operator preceding the string.", { index: token[tokenize_1.FIELDS.START_POS] });
						var _a = (0, attribute_1.unescapeValue)(content), unescaped = _a.unescaped, quoteMark = _a.quoteMark;
						node.value = unescaped;
						node.quoteMark = quoteMark;
						lastAdded = "value";
						(0, util_1.ensureObject)(node, "raws");
						node.raws.value = content;
						spaceAfterMeaningfulToken = false;
						break;
					case tokens.equals:
						if (!node.attribute) return this.expected("attribute", token[tokenize_1.FIELDS.START_POS], content);
						if (node.value) return this.error("Unexpected \"=\" found; an operator was already defined.", { index: token[tokenize_1.FIELDS.START_POS] });
						node.operator = node.operator ? node.operator + content : content;
						lastAdded = "operator";
						spaceAfterMeaningfulToken = false;
						break;
					case tokens.comment:
						if (lastAdded) {
							if (spaceAfterMeaningfulToken || next && next[tokenize_1.FIELDS.TYPE] === tokens.space || lastAdded === "insensitive") {
								var lastComment = (0, util_1.getProp)(node, "spaces", lastAdded, "after") || "";
								var rawLastComment = (0, util_1.getProp)(node, "raws", "spaces", lastAdded, "after") || lastComment;
								(0, util_1.ensureObject)(node, "raws", "spaces", lastAdded);
								node.raws.spaces[lastAdded].after = rawLastComment + content;
							} else {
								var lastValue = node[lastAdded] || "";
								var rawLastValue = (0, util_1.getProp)(node, "raws", lastAdded) || lastValue;
								(0, util_1.ensureObject)(node, "raws");
								node.raws[lastAdded] = rawLastValue + content;
							}
						} else commentBefore = commentBefore + content;
						break;
					default: return this.error("Unexpected \"".concat(content, "\" found."), { index: token[tokenize_1.FIELDS.START_POS] });
				}
				pos++;
			}
			unescapeProp(node, "attribute");
			unescapeProp(node, "namespace");
			this.newNode(new attribute_1.default(node));
			this.position++;
		};
		/**
		* return a node containing meaningless garbage up to (but not including) the specified token position.
		* if the token position is negative, all remaining tokens are consumed.
		*
		* This returns an array containing a single string node if all whitespace,
		* otherwise an array of comment nodes with space before and after.
		*
		* These tokens are not added to the current selector, the caller can add them or use them to amend
		* a previous node's space metadata.
		*
		* In lossy mode, this returns only comments.
		*/
		Parser.prototype.parseWhitespaceEquivalentTokens = function(stopPosition) {
			if (stopPosition < 0) stopPosition = this.tokens.length;
			var startPosition = this.position;
			var nodes = [];
			var space = "";
			var lastComment = void 0;
			do
				if (WHITESPACE_TOKENS[this.currToken[tokenize_1.FIELDS.TYPE]]) {
					if (!this.options.lossy) space += this.content();
				} else if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.comment) {
					var spaces = {};
					if (space) {
						spaces.before = space;
						space = "";
					}
					lastComment = new comment_1.default({
						value: this.content(),
						source: getTokenSource(this.currToken),
						sourceIndex: this.currToken[tokenize_1.FIELDS.START_POS],
						spaces
					});
					nodes.push(lastComment);
				}
			while (++this.position < stopPosition);
			if (space) {
				if (lastComment) lastComment.spaces.after = space;
				else if (!this.options.lossy) {
					var firstToken = this.tokens[startPosition];
					var lastToken = this.tokens[this.position - 1];
					nodes.push(new string_1.default({
						value: "",
						source: getSource(firstToken[tokenize_1.FIELDS.START_LINE], firstToken[tokenize_1.FIELDS.START_COL], lastToken[tokenize_1.FIELDS.END_LINE], lastToken[tokenize_1.FIELDS.END_COL]),
						sourceIndex: firstToken[tokenize_1.FIELDS.START_POS],
						spaces: {
							before: space,
							after: ""
						}
					}));
				}
			}
			return nodes;
		};
		/**
		*
		* @param {*} nodes
		*/
		Parser.prototype.convertWhitespaceNodesToSpace = function(nodes, requiredSpace) {
			var _this = this;
			if (requiredSpace === void 0) requiredSpace = false;
			var space = "";
			var rawSpace = "";
			nodes.forEach(function(n) {
				var spaceBefore = _this.lossySpace(n.spaces.before, requiredSpace);
				var rawSpaceBefore = _this.lossySpace(n.rawSpaceBefore, requiredSpace);
				space += spaceBefore + _this.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
				rawSpace += spaceBefore + n.value + _this.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
			});
			if (rawSpace === space) rawSpace = void 0;
			return {
				space,
				rawSpace
			};
		};
		Parser.prototype.isNamedCombinator = function(position) {
			if (position === void 0) position = this.position;
			return this.tokens[position + 0] && this.tokens[position + 0][tokenize_1.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][tokenize_1.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][tokenize_1.FIELDS.TYPE] === tokens.slash;
		};
		Parser.prototype.namedCombinator = function() {
			if (this.isNamedCombinator()) {
				var nameRaw = this.content(this.tokens[this.position + 1]);
				var name = (0, util_1.unesc)(nameRaw).toLowerCase();
				var raws = {};
				if (name !== nameRaw) raws.value = "/".concat(nameRaw, "/");
				var node = new combinator_1.default({
					value: "/".concat(name, "/"),
					source: getSource(this.currToken[tokenize_1.FIELDS.START_LINE], this.currToken[tokenize_1.FIELDS.START_COL], this.tokens[this.position + 2][tokenize_1.FIELDS.END_LINE], this.tokens[this.position + 2][tokenize_1.FIELDS.END_COL]),
					sourceIndex: this.currToken[tokenize_1.FIELDS.START_POS],
					raws
				});
				this.position = this.position + 3;
				return node;
			} else this.unexpected();
		};
		Parser.prototype.combinator = function() {
			var _this = this;
			if (this.content() === "|") return this.namespace();
			var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
			if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][tokenize_1.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][tokenize_1.FIELDS.TYPE] === tokens.closeParenthesis) {
				var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
				if (nodes.length > 0) {
					var last = this.current.last;
					if (last) {
						var _a = this.convertWhitespaceNodesToSpace(nodes), space = _a.space, rawSpace = _a.rawSpace;
						if (rawSpace !== void 0) last.rawSpaceAfter += rawSpace;
						last.spaces.after += space;
					} else nodes.forEach(function(n) {
						return _this.newNode(n);
					});
				}
				return;
			}
			var firstToken = this.currToken;
			var spaceOrDescendantSelectorNodes = void 0;
			if (nextSigTokenPos > this.position) spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
			var node;
			if (this.isNamedCombinator()) node = this.namedCombinator();
			else if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.combinator) {
				node = new combinator_1.default({
					value: this.content(),
					source: getTokenSource(this.currToken),
					sourceIndex: this.currToken[tokenize_1.FIELDS.START_POS]
				});
				this.position++;
			} else if (WHITESPACE_TOKENS[this.currToken[tokenize_1.FIELDS.TYPE]]) {} else if (!spaceOrDescendantSelectorNodes) this.unexpected();
			if (node) {
				if (spaceOrDescendantSelectorNodes) {
					var _b = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes), space = _b.space, rawSpace = _b.rawSpace;
					node.spaces.before = space;
					node.rawSpaceBefore = rawSpace;
				}
			} else {
				var _c = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true), space = _c.space, rawSpace = _c.rawSpace;
				if (!rawSpace) rawSpace = space;
				var spaces = {};
				var raws = { spaces: {} };
				if (space.endsWith(" ") && rawSpace.endsWith(" ")) {
					spaces.before = space.slice(0, space.length - 1);
					raws.spaces.before = rawSpace.slice(0, rawSpace.length - 1);
				} else if (space[0] === " " && rawSpace[0] === " ") {
					spaces.after = space.slice(1);
					raws.spaces.after = rawSpace.slice(1);
				} else raws.value = rawSpace;
				node = new combinator_1.default({
					value: " ",
					source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
					sourceIndex: firstToken[tokenize_1.FIELDS.START_POS],
					spaces,
					raws
				});
			}
			if (this.currToken && this.currToken[tokenize_1.FIELDS.TYPE] === tokens.space) {
				node.spaces.after = this.optionalSpace(this.content());
				this.position++;
			}
			return this.newNode(node);
		};
		Parser.prototype.comma = function() {
			if (this.position === this.tokens.length - 1) {
				this.root.trailingComma = true;
				this.position++;
				return;
			}
			this.current._inferEndPosition();
			var selector = new selector_1.default({
				source: { start: tokenStart(this.tokens[this.position + 1]) },
				sourceIndex: this.tokens[this.position + 1][tokenize_1.FIELDS.START_POS]
			});
			this.current.parent.append(selector);
			this.current = selector;
			this.position++;
		};
		Parser.prototype.comment = function() {
			var current = this.currToken;
			this.newNode(new comment_1.default({
				value: this.content(),
				source: getTokenSource(current),
				sourceIndex: current[tokenize_1.FIELDS.START_POS]
			}));
			this.position++;
		};
		Parser.prototype.error = function(message, opts) {
			throw this.root.error(message, opts);
		};
		Parser.prototype.missingBackslash = function() {
			return this.error("Expected a backslash preceding the semicolon.", { index: this.currToken[tokenize_1.FIELDS.START_POS] });
		};
		Parser.prototype.missingParenthesis = function() {
			return this.expected("opening parenthesis", this.currToken[tokenize_1.FIELDS.START_POS]);
		};
		Parser.prototype.missingSquareBracket = function() {
			return this.expected("opening square bracket", this.currToken[tokenize_1.FIELDS.START_POS]);
		};
		Parser.prototype.unexpected = function() {
			return this.error("Unexpected '".concat(this.content(), "'. Escaping special characters with \\ may help."), this.currToken[tokenize_1.FIELDS.START_POS]);
		};
		Parser.prototype.unexpectedPipe = function() {
			return this.error("Unexpected '|'.", this.currToken[tokenize_1.FIELDS.START_POS]);
		};
		Parser.prototype.namespace = function() {
			var prev = this.prevToken;
			var before = prev && (prev[tokenize_1.FIELDS.TYPE] === tokens.word || prev[tokenize_1.FIELDS.TYPE] === tokens.asterisk || prev[tokenize_1.FIELDS.TYPE] === tokens.ampersand) ? this.content(prev) : true;
			if (!this.nextToken) return this.unexpectedPipe();
			if (this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.word) {
				this.position++;
				return this.word(before);
			} else if (this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.asterisk) {
				this.position++;
				return this.universal(before);
			}
			this.unexpectedPipe();
		};
		Parser.prototype.nesting = function() {
			if (this.nextToken) {
				if (this.content(this.nextToken) === "|") {
					this.position++;
					return;
				}
			}
			var current = this.currToken;
			this.newNode(new nesting_1.default({
				value: this.content(),
				source: getTokenSource(current),
				sourceIndex: current[tokenize_1.FIELDS.START_POS]
			}));
			this.position++;
		};
		Parser.prototype.parentheses = function() {
			var last = this.current.last;
			var unbalanced = 1;
			var openingToken = this.currToken;
			this.position++;
			if (last && last.type === types.PSEUDO) {
				var selector = new selector_1.default({
					source: { start: tokenStart(this.tokens[this.position]) },
					sourceIndex: this.tokens[this.position][tokenize_1.FIELDS.START_POS]
				});
				var cache = this.current;
				last.append(selector);
				this.current = selector;
				this.nestingDepth++;
				try {
					if (this.nestingDepth > this.maxNestingDepth) this.error("Cannot parse selector: nesting depth exceeds the maximum of ".concat(this.maxNestingDepth, "."), { index: this.currToken[tokenize_1.FIELDS.START_POS] });
					while (this.position < this.tokens.length && unbalanced) {
						if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.openParenthesis) unbalanced++;
						if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.closeParenthesis) unbalanced--;
						if (unbalanced) this.parse();
						else {
							this.current.source.end = tokenEnd(this.currToken);
							this.current.parent.source.end = tokenEnd(this.currToken);
							this.position++;
						}
					}
				} finally {
					this.nestingDepth--;
				}
				this.current = cache;
			} else {
				var parenStart = this.currToken;
				var parenValue = "(";
				var parenEnd = void 0;
				while (this.position < this.tokens.length && unbalanced) {
					if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.openParenthesis) unbalanced++;
					if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.closeParenthesis) unbalanced--;
					parenEnd = this.currToken;
					parenValue += this.parseParenthesisToken(this.currToken);
					this.position++;
				}
				if (last) last.appendToPropertyAndEscape("value", parenValue, parenValue);
				else this.newNode(new string_1.default({
					value: parenValue,
					source: getSource(parenStart[tokenize_1.FIELDS.START_LINE], parenStart[tokenize_1.FIELDS.START_COL], parenEnd[tokenize_1.FIELDS.END_LINE], parenEnd[tokenize_1.FIELDS.END_COL]),
					sourceIndex: parenStart[tokenize_1.FIELDS.START_POS]
				}));
			}
			if (unbalanced) return this.expected("closing parenthesis", (this.currToken || openingToken)[tokenize_1.FIELDS.START_POS]);
		};
		Parser.prototype.pseudo = function() {
			var _this = this;
			var pseudoStr = "";
			var startingToken = this.currToken;
			while (this.currToken && this.currToken[tokenize_1.FIELDS.TYPE] === tokens.colon) {
				pseudoStr += this.content();
				this.position++;
			}
			if (!this.currToken) return this.expected(["pseudo-class", "pseudo-element"], this.position - 1);
			if (this.currToken[tokenize_1.FIELDS.TYPE] === tokens.word) this.splitWord(false, function(first, length) {
				pseudoStr += first;
				_this.newNode(new pseudo_1.default({
					value: pseudoStr,
					source: getTokenSourceSpan(startingToken, _this.currToken),
					sourceIndex: startingToken[tokenize_1.FIELDS.START_POS]
				}));
				if (length > 1 && _this.nextToken && _this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.openParenthesis) _this.error("Misplaced parenthesis.", { index: _this.nextToken[tokenize_1.FIELDS.START_POS] });
			});
			else return this.expected(["pseudo-class", "pseudo-element"], this.currToken[tokenize_1.FIELDS.START_POS]);
		};
		Parser.prototype.space = function() {
			var content = this.content();
			if (this.position === 0 || this.prevToken[tokenize_1.FIELDS.TYPE] === tokens.comma || this.prevToken[tokenize_1.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function(node) {
				return node.type === "comment";
			})) {
				this.spaces = this.optionalSpace(content);
				this.position++;
			} else if (this.position === this.tokens.length - 1 || this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.comma || this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.closeParenthesis) {
				this.current.last.spaces.after = this.optionalSpace(content);
				this.position++;
			} else this.combinator();
		};
		Parser.prototype.string = function() {
			var current = this.currToken;
			this.newNode(new string_1.default({
				value: this.content(),
				source: getTokenSource(current),
				sourceIndex: current[tokenize_1.FIELDS.START_POS]
			}));
			this.position++;
		};
		Parser.prototype.universal = function(namespace) {
			var nextToken = this.nextToken;
			if (nextToken && this.content(nextToken) === "|") {
				this.position++;
				return this.namespace();
			}
			var current = this.currToken;
			this.newNode(new universal_1.default({
				value: this.content(),
				source: getTokenSource(current),
				sourceIndex: current[tokenize_1.FIELDS.START_POS]
			}), namespace);
			this.position++;
		};
		Parser.prototype.splitWord = function(namespace, firstCallback) {
			var _this = this;
			var nextToken = this.nextToken;
			var word = this.content();
			while (nextToken && ~[
				tokens.dollar,
				tokens.caret,
				tokens.equals,
				tokens.word
			].indexOf(nextToken[tokenize_1.FIELDS.TYPE])) {
				this.position++;
				var current = this.content();
				word += current;
				if (current.lastIndexOf("\\") === current.length - 1) {
					var next = this.nextToken;
					if (next && next[tokenize_1.FIELDS.TYPE] === tokens.space) {
						word += this.requiredSpace(this.content(next));
						this.position++;
					}
				}
				nextToken = this.nextToken;
			}
			var hasClass = indexesOf(word, ".").filter(function(i) {
				var escapedDot = word[i - 1] === "\\";
				var isKeyframesPercent = /^\d+\.\d+%$/.test(word);
				return !escapedDot && !isKeyframesPercent;
			});
			var hasId = indexesOf(word, "#").filter(function(i) {
				return word[i - 1] !== "\\";
			});
			var interpolations = indexesOf(word, "#{");
			if (interpolations.length) {
				var interpolationIndexes_1 = new Set(interpolations);
				hasId = hasId.filter(function(hashIndex) {
					return !interpolationIndexes_1.has(hashIndex);
				});
			}
			var classIndexes = new Set(hasClass);
			var idIndexes = new Set(hasId);
			var indices = (0, sortAscending_1.default)(uniqs(__spreadArray(__spreadArray([0], __read(hasClass), false), __read(hasId), false)));
			indices.forEach(function(ind, i) {
				var index = indices[i + 1] || word.length;
				var value = word.slice(ind, index);
				if (i === 0 && firstCallback) return firstCallback.call(_this, value, indices.length);
				var node;
				var current = _this.currToken;
				var sourceIndex = current[tokenize_1.FIELDS.START_POS] + indices[i];
				var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
				if (classIndexes.has(ind)) {
					var classNameOpts = {
						value: value.slice(1),
						source,
						sourceIndex
					};
					node = new className_1.default(unescapeProp(classNameOpts, "value"));
				} else if (idIndexes.has(ind)) {
					var idOpts = {
						value: value.slice(1),
						source,
						sourceIndex
					};
					node = new id_1.default(unescapeProp(idOpts, "value"));
				} else {
					var tagOpts = {
						value,
						source,
						sourceIndex
					};
					unescapeProp(tagOpts, "value");
					node = new tag_1.default(tagOpts);
				}
				_this.newNode(node, namespace);
				namespace = null;
			});
			this.position++;
		};
		Parser.prototype.word = function(namespace) {
			var nextToken = this.nextToken;
			if (nextToken && this.content(nextToken) === "|") {
				this.position++;
				return this.namespace();
			}
			return this.splitWord(namespace);
		};
		Parser.prototype.loop = function() {
			while (this.position < this.tokens.length) this.parse(true);
			this.current._inferEndPosition();
			return this.root;
		};
		Parser.prototype.parse = function(throwOnParenthesis) {
			switch (this.currToken[tokenize_1.FIELDS.TYPE]) {
				case tokens.space:
					this.space();
					break;
				case tokens.comment:
					this.comment();
					break;
				case tokens.openParenthesis:
					this.parentheses();
					break;
				case tokens.closeParenthesis:
					if (throwOnParenthesis) this.missingParenthesis();
					break;
				case tokens.openSquare:
					this.attribute();
					break;
				case tokens.dollar:
				case tokens.caret:
				case tokens.equals:
				case tokens.word:
					this.word();
					break;
				case tokens.colon:
					this.pseudo();
					break;
				case tokens.comma:
					this.comma();
					break;
				case tokens.asterisk:
					this.universal();
					break;
				case tokens.ampersand:
					this.nesting();
					break;
				case tokens.slash:
				case tokens.combinator:
					this.combinator();
					break;
				case tokens.str:
					this.string();
					break;
				case tokens.closeSquare: this.missingSquareBracket();
				case tokens.semicolon: this.missingBackslash();
				default: this.unexpected();
			}
		};
		/**
		* Helpers
		*/
		Parser.prototype.expected = function(description, index, found) {
			if (Array.isArray(description)) {
				var last = description.pop();
				description = "".concat(description.join(", "), " or ").concat(last);
			}
			var an = /^[aeiou]/.test(description[0]) ? "an" : "a";
			if (!found) return this.error("Expected ".concat(an, " ").concat(description, "."), { index });
			return this.error("Expected ".concat(an, " ").concat(description, ", found \"").concat(found, "\" instead."), { index });
		};
		Parser.prototype.requiredSpace = function(space) {
			return this.options.lossy ? " " : space;
		};
		Parser.prototype.optionalSpace = function(space) {
			return this.options.lossy ? "" : space;
		};
		Parser.prototype.lossySpace = function(space, required) {
			if (this.options.lossy) return required ? " " : "";
			else return space;
		};
		Parser.prototype.parseParenthesisToken = function(token) {
			var content = this.content(token);
			if (token[tokenize_1.FIELDS.TYPE] === tokens.space) return this.requiredSpace(content);
			else return content;
		};
		Parser.prototype.newNode = function(node, namespace) {
			if (namespace) {
				if (/^ +$/.test(namespace)) {
					if (!this.options.lossy) this.spaces = (this.spaces || "") + namespace;
					namespace = true;
				}
				node.namespace = namespace;
				unescapeProp(node, "namespace");
			}
			if (this.spaces) {
				node.spaces.before = this.spaces;
				this.spaces = "";
			}
			return this.current.append(node);
		};
		Parser.prototype.content = function(token) {
			if (token === void 0) token = this.currToken;
			return this.css.slice(token[tokenize_1.FIELDS.START_POS], token[tokenize_1.FIELDS.END_POS]);
		};
		Object.defineProperty(Parser.prototype, "currToken", {
			get: function() {
				return this.tokens[this.position];
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Parser.prototype, "nextToken", {
			get: function() {
				return this.tokens[this.position + 1];
			},
			enumerable: false,
			configurable: true
		});
		Object.defineProperty(Parser.prototype, "prevToken", {
			get: function() {
				return this.tokens[this.position - 1];
			},
			enumerable: false,
			configurable: true
		});
		/**
		* returns the index of the next non-whitespace, non-comment token.
		* returns -1 if no meaningful token is found.
		*/
		Parser.prototype.locateNextMeaningfulToken = function(startPosition) {
			if (startPosition === void 0) startPosition = this.position + 1;
			var searchPosition = startPosition;
			while (searchPosition < this.tokens.length) if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][tokenize_1.FIELDS.TYPE]]) {
				searchPosition++;
				continue;
			} else return searchPosition;
			return -1;
		};
		return Parser;
	}();
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/processor.js
var require_processor = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	var parser_1 = __importDefault(require_parser());
	exports.default = function() {
		function Processor(func, options) {
			this.func = func || function noop() {};
			this.funcRes = null;
			this.options = options;
		}
		Processor.prototype._shouldUpdateSelector = function(rule, options) {
			if (options === void 0) options = {};
			if (Object.assign({}, this.options, options).updateSelector === false) return false;
			else return typeof rule !== "string";
		};
		Processor.prototype._isLossy = function(options) {
			if (options === void 0) options = {};
			if (Object.assign({}, this.options, options).lossless === false) return true;
			else return false;
		};
		Processor.prototype._root = function(rule, options) {
			if (options === void 0) options = {};
			return new parser_1.default(rule, this._parseOptions(options)).root;
		};
		Processor.prototype._parseOptions = function(options) {
			var merged = Object.assign({}, this.options, options);
			return {
				lossy: this._isLossy(merged),
				maxNestingDepth: merged.maxNestingDepth
			};
		};
		Processor.prototype._stringifyOptions = function(options) {
			return { maxNestingDepth: Object.assign({}, this.options, options).maxNestingDepth };
		};
		Processor.prototype._run = function(rule, options) {
			var _this = this;
			if (options === void 0) options = {};
			return new Promise(function(resolve, reject) {
				try {
					var root_1 = _this._root(rule, options);
					Promise.resolve(_this.func(root_1)).then(function(transform) {
						var string = void 0;
						if (_this._shouldUpdateSelector(rule, options)) {
							string = root_1.toString(_this._stringifyOptions(options));
							rule.selector = string;
						}
						return {
							transform,
							root: root_1,
							string
						};
					}).then(resolve, reject);
				} catch (e) {
					reject(e);
					return;
				}
			});
		};
		Processor.prototype._runSync = function(rule, options) {
			if (options === void 0) options = {};
			var root = this._root(rule, options);
			var transform = this.func(root);
			if (transform && typeof transform.then === "function") throw new Error("Selector processor returned a promise to a synchronous call.");
			var string = void 0;
			if (options.updateSelector && typeof rule !== "string") {
				string = root.toString(this._stringifyOptions(options));
				rule.selector = string;
			}
			return {
				transform,
				root,
				string
			};
		};
		/**
		* Process rule into a selector AST.
		*
		* @param rule {postcss.Rule | string} The css selector to be processed
		* @param options The options for processing
		* @returns {Promise<parser.Root>} The AST of the selector after processing it.
		*/
		Processor.prototype.ast = function(rule, options) {
			return this._run(rule, options).then(function(result) {
				return result.root;
			});
		};
		/**
		* Process rule into a selector AST synchronously.
		*
		* @param rule {postcss.Rule | string} The css selector to be processed
		* @param options The options for processing
		* @returns {parser.Root} The AST of the selector after processing it.
		*/
		Processor.prototype.astSync = function(rule, options) {
			return this._runSync(rule, options).root;
		};
		/**
		* Process a selector into a transformed value asynchronously
		*
		* @param rule {postcss.Rule | string} The css selector to be processed
		* @param options The options for processing
		* @returns {Promise<any>} The value returned by the processor.
		*/
		Processor.prototype.transform = function(rule, options) {
			return this._run(rule, options).then(function(result) {
				return result.transform;
			});
		};
		/**
		* Process a selector into a transformed value synchronously.
		*
		* @param rule {postcss.Rule | string} The css selector to be processed
		* @param options The options for processing
		* @returns {any} The value returned by the processor.
		*/
		Processor.prototype.transformSync = function(rule, options) {
			return this._runSync(rule, options).transform;
		};
		/**
		* Process a selector into a new selector string asynchronously.
		*
		* @param rule {postcss.Rule | string} The css selector to be processed
		* @param options The options for processing
		* @returns {string} the selector after processing.
		*/
		Processor.prototype.process = function(rule, options) {
			var _this = this;
			return this._run(rule, options).then(function(result) {
				return result.string || result.root.toString(_this._stringifyOptions(options));
			});
		};
		/**
		* Process a selector into a new selector string synchronously.
		*
		* @param rule {postcss.Rule | string} The css selector to be processed
		* @param options The options for processing
		* @returns {string} the selector after processing.
		*/
		Processor.prototype.processSync = function(rule, options) {
			var result = this._runSync(rule, options);
			return result.string || result.root.toString(this._stringifyOptions(options));
		};
		return Processor;
	}();
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/constructors.js
var require_constructors = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __importDefault = exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
	var attribute_1 = __importDefault(require_attribute());
	var className_1 = __importDefault(require_className());
	var combinator_1 = __importDefault(require_combinator());
	var comment_1 = __importDefault(require_comment());
	var id_1 = __importDefault(require_id());
	var nesting_1 = __importDefault(require_nesting());
	var pseudo_1 = __importDefault(require_pseudo());
	var root_1 = __importDefault(require_root());
	var selector_1 = __importDefault(require_selector());
	var string_1 = __importDefault(require_string());
	var tag_1 = __importDefault(require_tag());
	var universal_1 = __importDefault(require_universal());
	var attribute = function(opts) {
		return new attribute_1.default(opts);
	};
	exports.attribute = attribute;
	var className = function(opts) {
		return new className_1.default(opts);
	};
	exports.className = className;
	var combinator = function(opts) {
		return new combinator_1.default(opts);
	};
	exports.combinator = combinator;
	var comment = function(opts) {
		return new comment_1.default(opts);
	};
	exports.comment = comment;
	var id = function(opts) {
		return new id_1.default(opts);
	};
	exports.id = id;
	var nesting = function(opts) {
		return new nesting_1.default(opts);
	};
	exports.nesting = nesting;
	var pseudo = function(opts) {
		return new pseudo_1.default(opts);
	};
	exports.pseudo = pseudo;
	var root = function(opts) {
		return new root_1.default(opts);
	};
	exports.root = root;
	var selector = function(opts) {
		return new selector_1.default(opts);
	};
	exports.selector = selector;
	var string = function(opts) {
		return new string_1.default(opts);
	};
	exports.string = string;
	var tag = function(opts) {
		return new tag_1.default(opts);
	};
	exports.tag = tag;
	var universal = function(opts) {
		return new universal_1.default(opts);
	};
	exports.universal = universal;
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/guards.js
var require_guards = /* @__PURE__ */ __commonJSMin(((exports) => {
	var _a;
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = exports.isPseudo = exports.isNesting = exports.isIdentifier = exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
	exports.isNode = isNode;
	exports.isPseudoElement = isPseudoElement;
	exports.isPseudoClass = isPseudoClass;
	exports.isContainer = isContainer;
	exports.isNamespace = isNamespace;
	var types_1 = require_types();
	var IS_TYPE = (_a = {}, _a[types_1.ATTRIBUTE] = true, _a[types_1.CLASS] = true, _a[types_1.COMBINATOR] = true, _a[types_1.COMMENT] = true, _a[types_1.ID] = true, _a[types_1.NESTING] = true, _a[types_1.PSEUDO] = true, _a[types_1.ROOT] = true, _a[types_1.SELECTOR] = true, _a[types_1.STRING] = true, _a[types_1.TAG] = true, _a[types_1.UNIVERSAL] = true, _a);
	function isNode(node) {
		return typeof node === "object" && IS_TYPE[node.type];
	}
	function isNodeType(type, node) {
		return isNode(node) && node.type === type;
	}
	exports.isAttribute = isNodeType.bind(null, types_1.ATTRIBUTE);
	exports.isClassName = isNodeType.bind(null, types_1.CLASS);
	exports.isCombinator = isNodeType.bind(null, types_1.COMBINATOR);
	exports.isComment = isNodeType.bind(null, types_1.COMMENT);
	exports.isIdentifier = isNodeType.bind(null, types_1.ID);
	exports.isNesting = isNodeType.bind(null, types_1.NESTING);
	exports.isPseudo = isNodeType.bind(null, types_1.PSEUDO);
	exports.isRoot = isNodeType.bind(null, types_1.ROOT);
	exports.isSelector = isNodeType.bind(null, types_1.SELECTOR);
	exports.isString = isNodeType.bind(null, types_1.STRING);
	exports.isTag = isNodeType.bind(null, types_1.TAG);
	exports.isUniversal = isNodeType.bind(null, types_1.UNIVERSAL);
	function isPseudoElement(node) {
		return (0, exports.isPseudo)(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
	}
	function isPseudoClass(node) {
		return (0, exports.isPseudo)(node) && !isPseudoElement(node);
	}
	function isContainer(node) {
		return !!(isNode(node) && node.walk);
	}
	function isNamespace(node) {
		return (0, exports.isAttribute)(node) || (0, exports.isTag)(node);
	}
}));
//#endregion
//#region node_modules/.pnpm/postcss-selector-parser@7.1.6/node_modules/postcss-selector-parser/dist/selectors/index.js
var require_selectors = /* @__PURE__ */ __commonJSMin(((exports) => {
	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
			enumerable: true,
			get: function() {
				return m[k];
			}
		};
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		o[k2] = m[k];
	}));
	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
	};
	Object.defineProperty(exports, "__esModule", { value: true });
	__exportStar(require_types(), exports);
	__exportStar(require_constructors(), exports);
	__exportStar(require_guards(), exports);
}));
//#endregion
//#region packages/compiler-sfc/src/style/pluginScoped.ts
var import_dist = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
			enumerable: true,
			get: function() {
				return m[k];
			}
		};
		Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
		if (k2 === void 0) k2 = k;
		o[k2] = m[k];
	}));
	var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", {
			enumerable: true,
			value: v
		});
	}) : function(o, v) {
		o["default"] = v;
	});
	var __importStar = exports && exports.__importStar || (function() {
		var ownKeys = function(o) {
			ownKeys = Object.getOwnPropertyNames || function(o) {
				var ar = [];
				for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
				return ar;
			};
			return ownKeys(o);
		};
		return function(mod) {
			if (mod && mod.__esModule) return mod;
			var result = {};
			if (mod != null) {
				for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
			}
			__setModuleDefault(result, mod);
			return result;
		};
	})();
	var processor_1 = (exports && exports.__importDefault || function(mod) {
		return mod && mod.__esModule ? mod : { "default": mod };
	})(require_processor());
	var selectors = __importStar(require_selectors());
	var parser = function(processor) {
		return new processor_1.default(processor);
	};
	Object.assign(parser, selectors);
	delete parser.__esModule;
	module.exports = parser;
})))());
const animationNameRE = /^(?:-\w+-)?animation-name$/;
const animationRE = /^(?:-\w+-)?animation$/;
const keyframesRE = /^(?:-\w+-)?keyframes$/;
const scopedPlugin = (id = "") => {
	const keyframes = Object.create(null);
	const shortId = id.replace(/^data-v-/, "");
	return {
		postcssPlugin: "vue-sfc-scoped",
		Rule(rule) {
			processRule(id, rule);
		},
		AtRule(node) {
			if (keyframesRE.test(node.name) && !node.params.endsWith(`-${shortId}`)) keyframes[node.params] = node.params = node.params + "-" + shortId;
		},
		OnceExit(root) {
			if (Object.keys(keyframes).length) root.walkDecls((decl) => {
				if (animationNameRE.test(decl.prop)) decl.value = decl.value.split(",").map((v) => keyframes[v.trim()] || v.trim()).join(",");
				if (animationRE.test(decl.prop)) decl.value = decl.value.split(",").map((v) => {
					const vals = v.trim().split(/\s+/);
					const i = vals.findIndex((val) => keyframes[val]);
					if (i !== -1) {
						vals.splice(i, 1, keyframes[vals[i]]);
						return vals.join(" ");
					} else return v;
				}).join(",");
			});
		}
	};
};
const processedRules = /* @__PURE__ */ new WeakSet();
function processRule(id, rule) {
	if (processedRules.has(rule) || rule.parent && rule.parent.type === "atrule" && keyframesRE.test(rule.parent.name)) return;
	processedRules.add(rule);
	let deep = false;
	let parent = rule.parent;
	while (parent && parent.type !== "root") {
		if (parent.__deep) {
			deep = true;
			break;
		}
		parent = parent.parent;
	}
	rule.selector = (0, import_dist.default)((selectorRoot) => {
		selectorRoot.each((selector) => {
			rewriteSelector(id, rule, selector, selectorRoot, deep);
		});
	}).processSync(rule.selector);
}
function rewriteSelector(id, rule, selector, selectorRoot, deep, slotted = false) {
	let node = null;
	let shouldInject = !deep;
	let hasNestedDeep = false;
	let splitForNestedDeep = false;
	selector.each((n) => {
		if (n.type === "combinator" && (n.value === ">>>" || n.value === "/deep/")) {
			n.value = " ";
			n.spaces.before = n.spaces.after = "";
			warn("the >>> and /deep/ combinators have been deprecated. Use :deep() instead.");
			return false;
		}
		if (n.type === "pseudo") {
			const { value } = n;
			if (isDeepContainerPseudo(n)) {
				if (n.nodes.some((selector) => selector.some(isDeepSelector))) {
					const hasScopeAnchor = !!node;
					const hasMixedSelectors = n.nodes.some((selector) => !selector.some(isDeepSelector));
					const hasTrailingNodes = selector.index(n) < selector.length - 1;
					if (canSplitDeepContainerPseudo(n) && !deep && !hasScopeAnchor && hasMixedSelectors && hasTrailingNodes) {
						splitSelectorForNestedDeep(id, rule, selector, selectorRoot, n, deep, slotted);
						splitForNestedDeep = true;
						return false;
					}
					if (value === ":not" && !deep && !hasScopeAnchor && hasMixedSelectors && hasTrailingNodes) return;
					n.nodes.forEach((selector) => rewriteSelector(id, rule, selector, selectorRoot, deep || hasScopeAnchor, slotted));
					if (!hasScopeAnchor) {
						node = n;
						shouldInject = false;
					}
					hasNestedDeep = true;
				}
			}
			if (value === ":deep" || value === "::v-deep") {
				rule.__deep = true;
				if (n.nodes.length) {
					let last = n;
					n.nodes[0].each((ss) => {
						selector.insertAfter(last, ss);
						last = ss;
					});
					const prev = selector.at(selector.index(n) - 1);
					if (!prev || !isSpaceCombinator(prev)) selector.insertAfter(n, import_dist.default.combinator({ value: " " }));
					selector.removeChild(n);
				} else {
					warn(`${value} usage as a combinator has been deprecated. Use :deep(<inner-selector>) instead of ${value} <inner-selector>.`);
					const prev = selector.at(selector.index(n) - 1);
					if (prev && isSpaceCombinator(prev)) selector.removeChild(prev);
					selector.removeChild(n);
				}
				return false;
			}
			if (value === ":slotted" || value === "::v-slotted") {
				rewriteSelector(id, rule, n.nodes[0], selectorRoot, deep, true);
				let last = n;
				n.nodes[0].each((ss) => {
					selector.insertAfter(last, ss);
					last = ss;
				});
				selector.removeChild(n);
				shouldInject = false;
				return false;
			}
			if (value === ":global" || value === "::v-global") {
				selector.replaceWith(n.nodes[0]);
				return false;
			}
		}
		if (n.type === "universal") {
			const prev = selector.at(selector.index(n) - 1);
			const next = selector.at(selector.index(n) + 1);
			if (!prev) {
				if (next) {
					if (next.type === "combinator" && next.value === " ") selector.removeChild(next);
					selector.removeChild(n);
					return;
				} else {
					node = import_dist.default.combinator({ value: "" });
					selector.insertBefore(n, node);
					selector.removeChild(n);
					return false;
				}
			}
			if (node) return;
		}
		if (!hasNestedDeep && (n.type !== "pseudo" && n.type !== "combinator" || n.type === "pseudo" && (n.value === ":is" || n.value === ":where") && !node)) node = n;
	});
	if (splitForNestedDeep) return;
	if (rule.nodes.some((node) => node.type === "rule")) {
		const deep = rule.__deep;
		if (!deep) {
			extractAndWrapNodes(rule);
			const atruleNodes = rule.nodes.filter((node) => node.type === "atrule");
			for (const atnode of atruleNodes) extractAndWrapNodes(atnode);
		}
		shouldInject = deep;
	}
	if (node && !hasNestedDeep) {
		const { type, value } = node;
		if (type === "pseudo" && (value === ":is" || value === ":where")) {
			node.nodes.forEach((value) => rewriteSelector(id, rule, value, selectorRoot, deep, slotted));
			shouldInject = false;
		}
	}
	if (node) node.spaces.after = "";
	else selector.first.spaces.before = "";
	if (shouldInject) {
		const idToAdd = slotted ? id + "-s" : id;
		selector.insertAfter(node, import_dist.default.attribute({
			attribute: idToAdd,
			value: idToAdd,
			raws: {},
			quoteMark: `"`
		}));
	}
}
function isSpaceCombinator(node) {
	return node.type === "combinator" && /^\s+$/.test(node.value);
}
function isDeepSelector(node) {
	var _nodes;
	if (node.type === "pseudo" && (node.value === ":deep" || node.value === "::v-deep")) return true;
	return !!((_nodes = node.nodes) === null || _nodes === void 0 ? void 0 : _nodes.some((child) => isDeepSelector(child)));
}
function isDeepContainerPseudo(node) {
	return node.type === "pseudo" && (node.value === ":is" || node.value === ":where" || node.value === ":has" || node.value === ":not");
}
function canSplitDeepContainerPseudo(node) {
	return node.value === ":is" || node.value === ":where" || node.value === ":has";
}
function splitSelectorForNestedDeep(id, rule, selector, selectorRoot, pseudo, deep, slotted) {
	const pseudoIndex = selector.index(pseudo);
	const selectors = pseudo.nodes.map((branch, index) => {
		const branchSelector = selector.clone();
		if (branchSelector.first) branchSelector.first.spaces.before = index === 0 ? selector.first.spaces.before : " ";
		const branchPseudo = branchSelector.at(pseudoIndex);
		const branchClone = branch.clone();
		if (branchClone.first) branchClone.first.spaces.before = "";
		branchPseudo.removeAll();
		branchPseudo.append(branchClone);
		rewriteSelector(id, rule, branchSelector, selectorRoot, deep, slotted);
		return branchSelector;
	});
	selector.replaceWith(...selectors);
}
function extractAndWrapNodes(parentNode) {
	if (!parentNode.nodes) return;
	const nodes = parentNode.nodes.filter((node) => node.type === "decl" || node.type === "comment");
	if (nodes.length) {
		for (const node of nodes) parentNode.removeChild(node);
		const wrappedRule = new Rule({
			nodes,
			selector: "&"
		});
		parentNode.prepend(wrappedRule);
	}
}
scopedPlugin.postcss = true;
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64.js
var require_base64 = /* @__PURE__ */ __commonJSMin(((exports) => {
	var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
	/**
	* Encode an integer in the range of 0 to 63 to a single base 64 digit.
	*/
	exports.encode = function(number) {
		if (0 <= number && number < intToCharMap.length) return intToCharMap[number];
		throw new TypeError("Must be between 0 and 63: " + number);
	};
	/**
	* Decode a single base 64 character code digit to an integer. Returns -1 on
	* failure.
	*/
	exports.decode = function(charCode) {
		var bigA = 65;
		var bigZ = 90;
		var littleA = 97;
		var littleZ = 122;
		var zero = 48;
		var nine = 57;
		var plus = 43;
		var slash = 47;
		var littleOffset = 26;
		var numberOffset = 52;
		if (bigA <= charCode && charCode <= bigZ) return charCode - bigA;
		if (littleA <= charCode && charCode <= littleZ) return charCode - littleA + littleOffset;
		if (zero <= charCode && charCode <= nine) return charCode - zero + numberOffset;
		if (charCode == plus) return 62;
		if (charCode == slash) return 63;
		return -1;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/base64-vlq.js
var require_base64_vlq = /* @__PURE__ */ __commonJSMin(((exports) => {
	var base64 = require_base64();
	var VLQ_BASE_SHIFT = 5;
	var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
	var VLQ_BASE_MASK = VLQ_BASE - 1;
	var VLQ_CONTINUATION_BIT = VLQ_BASE;
	/**
	* Converts from a two-complement value to a value where the sign bit is
	* placed in the least significant bit.  For example, as decimals:
	*   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
	*   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
	*/
	function toVLQSigned(aValue) {
		return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
	}
	/**
	* Converts to a two-complement value from a value where the sign bit is
	* placed in the least significant bit.  For example, as decimals:
	*   2 (10 binary) becomes 1, 3 (11 binary) becomes -1
	*   4 (100 binary) becomes 2, 5 (101 binary) becomes -2
	*/
	function fromVLQSigned(aValue) {
		var isNegative = (aValue & 1) === 1;
		var shifted = aValue >> 1;
		return isNegative ? -shifted : shifted;
	}
	/**
	* Returns the base 64 VLQ encoded value.
	*/
	exports.encode = function base64VLQ_encode(aValue) {
		var encoded = "";
		var digit;
		var vlq = toVLQSigned(aValue);
		do {
			digit = vlq & VLQ_BASE_MASK;
			vlq >>>= VLQ_BASE_SHIFT;
			if (vlq > 0) digit |= VLQ_CONTINUATION_BIT;
			encoded += base64.encode(digit);
		} while (vlq > 0);
		return encoded;
	};
	/**
	* Decodes the next base 64 VLQ value from the given string and returns the
	* value and the rest of the string via the out parameter.
	*/
	exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
		var strLen = aStr.length;
		var result = 0;
		var shift = 0;
		var continuation, digit;
		do {
			if (aIndex >= strLen) throw new Error("Expected more digits in base 64 VLQ value.");
			digit = base64.decode(aStr.charCodeAt(aIndex++));
			if (digit === -1) throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
			continuation = !!(digit & VLQ_CONTINUATION_BIT);
			digit &= VLQ_BASE_MASK;
			result = result + (digit << shift);
			shift += VLQ_BASE_SHIFT;
		} while (continuation);
		aOutParam.value = fromVLQSigned(result);
		aOutParam.rest = aIndex;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/util.js
var require_util = /* @__PURE__ */ __commonJSMin(((exports) => {
	/**
	* This is a helper function for getting values from parameter/options
	* objects.
	*
	* @param args The object we are extracting values from
	* @param name The name of the property we are getting.
	* @param defaultValue An optional value to return if the property is missing
	* from the object. If this is not specified and the property is missing, an
	* error will be thrown.
	*/
	function getArg(aArgs, aName, aDefaultValue) {
		if (aName in aArgs) return aArgs[aName];
		else if (arguments.length === 3) return aDefaultValue;
		else throw new Error("\"" + aName + "\" is a required argument.");
	}
	exports.getArg = getArg;
	var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
	var dataUrlRegexp = /^data:.+\,.+$/;
	function urlParse(aUrl) {
		var match = aUrl.match(urlRegexp);
		if (!match) return null;
		return {
			scheme: match[1],
			auth: match[2],
			host: match[3],
			port: match[4],
			path: match[5]
		};
	}
	exports.urlParse = urlParse;
	function urlGenerate(aParsedUrl) {
		var url = "";
		if (aParsedUrl.scheme) url += aParsedUrl.scheme + ":";
		url += "//";
		if (aParsedUrl.auth) url += aParsedUrl.auth + "@";
		if (aParsedUrl.host) url += aParsedUrl.host;
		if (aParsedUrl.port) url += ":" + aParsedUrl.port;
		if (aParsedUrl.path) url += aParsedUrl.path;
		return url;
	}
	exports.urlGenerate = urlGenerate;
	/**
	* Normalizes a path, or the path portion of a URL:
	*
	* - Replaces consecutive slashes with one slash.
	* - Removes unnecessary '.' parts.
	* - Removes unnecessary '<dir>/..' parts.
	*
	* Based on code in the Node.js 'path' core module.
	*
	* @param aPath The path or url to normalize.
	*/
	function normalize(aPath) {
		var path = aPath;
		var url = urlParse(aPath);
		if (url) {
			if (!url.path) return aPath;
			path = url.path;
		}
		var isAbsolute = exports.isAbsolute(path);
		var parts = path.split(/\/+/);
		for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
			part = parts[i];
			if (part === ".") parts.splice(i, 1);
			else if (part === "..") up++;
			else if (up > 0) {
				if (part === "") {
					parts.splice(i + 1, up);
					up = 0;
				} else {
					parts.splice(i, 2);
					up--;
				}
			}
		}
		path = parts.join("/");
		if (path === "") path = isAbsolute ? "/" : ".";
		if (url) {
			url.path = path;
			return urlGenerate(url);
		}
		return path;
	}
	exports.normalize = normalize;
	/**
	* Joins two paths/URLs.
	*
	* @param aRoot The root path or URL.
	* @param aPath The path or URL to be joined with the root.
	*
	* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
	*   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
	*   first.
	* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
	*   is updated with the result and aRoot is returned. Otherwise the result
	*   is returned.
	*   - If aPath is absolute, the result is aPath.
	*   - Otherwise the two paths are joined with a slash.
	* - Joining for example 'http://' and 'www.example.com' is also supported.
	*/
	function join(aRoot, aPath) {
		if (aRoot === "") aRoot = ".";
		if (aPath === "") aPath = ".";
		var aPathUrl = urlParse(aPath);
		var aRootUrl = urlParse(aRoot);
		if (aRootUrl) aRoot = aRootUrl.path || "/";
		if (aPathUrl && !aPathUrl.scheme) {
			if (aRootUrl) aPathUrl.scheme = aRootUrl.scheme;
			return urlGenerate(aPathUrl);
		}
		if (aPathUrl || aPath.match(dataUrlRegexp)) return aPath;
		if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
			aRootUrl.host = aPath;
			return urlGenerate(aRootUrl);
		}
		var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
		if (aRootUrl) {
			aRootUrl.path = joined;
			return urlGenerate(aRootUrl);
		}
		return joined;
	}
	exports.join = join;
	exports.isAbsolute = function(aPath) {
		return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
	};
	/**
	* Make a path relative to a URL or another path.
	*
	* @param aRoot The root path or URL.
	* @param aPath The path or URL to be made relative to aRoot.
	*/
	function relative(aRoot, aPath) {
		if (aRoot === "") aRoot = ".";
		aRoot = aRoot.replace(/\/$/, "");
		var level = 0;
		while (aPath.indexOf(aRoot + "/") !== 0) {
			var index = aRoot.lastIndexOf("/");
			if (index < 0) return aPath;
			aRoot = aRoot.slice(0, index);
			if (aRoot.match(/^([^\/]+:\/)?\/*$/)) return aPath;
			++level;
		}
		return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
	}
	exports.relative = relative;
	var supportsNullProto = function() {
		return !("__proto__" in Object.create(null));
	}();
	function identity(s) {
		return s;
	}
	/**
	* Because behavior goes wacky when you set `__proto__` on objects, we
	* have to prefix all the strings in our set with an arbitrary character.
	*
	* See https://github.com/mozilla/source-map/pull/31 and
	* https://github.com/mozilla/source-map/issues/30
	*
	* @param String aStr
	*/
	function toSetString(aStr) {
		if (isProtoString(aStr)) return "$" + aStr;
		return aStr;
	}
	exports.toSetString = supportsNullProto ? identity : toSetString;
	function fromSetString(aStr) {
		if (isProtoString(aStr)) return aStr.slice(1);
		return aStr;
	}
	exports.fromSetString = supportsNullProto ? identity : fromSetString;
	function isProtoString(s) {
		if (!s) return false;
		var length = s.length;
		if (length < 9) return false;
		if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) return false;
		for (var i = length - 10; i >= 0; i--) if (s.charCodeAt(i) !== 36) return false;
		return true;
	}
	/**
	* Comparator between two mappings where the original positions are compared.
	*
	* Optionally pass in `true` as `onlyCompareGenerated` to consider two
	* mappings with the same original source/line/column, but different generated
	* line and column the same. Useful when searching for a mapping with a
	* stubbed out mapping.
	*/
	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
		var cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0 || onlyCompareOriginal) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByOriginalPositions = compareByOriginalPositions;
	/**
	* Comparator between two mappings with deflated source and name indices where
	* the generated positions are compared.
	*
	* Optionally pass in `true` as `onlyCompareGenerated` to consider two
	* mappings with the same generated line and column, but different
	* source/name/original line and column the same. Useful when searching for a
	* mapping with a stubbed out mapping.
	*/
	function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
		var cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0 || onlyCompareGenerated) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
	function strcmp(aStr1, aStr2) {
		if (aStr1 === aStr2) return 0;
		if (aStr1 === null) return 1;
		if (aStr2 === null) return -1;
		if (aStr1 > aStr2) return 1;
		return -1;
	}
	/**
	* Comparator between two mappings with inflated source and name strings where
	* the generated positions are compared.
	*/
	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
		var cmp = mappingA.generatedLine - mappingB.generatedLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.generatedColumn - mappingB.generatedColumn;
		if (cmp !== 0) return cmp;
		cmp = strcmp(mappingA.source, mappingB.source);
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalLine - mappingB.originalLine;
		if (cmp !== 0) return cmp;
		cmp = mappingA.originalColumn - mappingB.originalColumn;
		if (cmp !== 0) return cmp;
		return strcmp(mappingA.name, mappingB.name);
	}
	exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
	/**
	* Strip any JSON XSSI avoidance prefix from the string (as documented
	* in the source maps specification), and then parse the string as
	* JSON.
	*/
	function parseSourceMapInput(str) {
		return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
	}
	exports.parseSourceMapInput = parseSourceMapInput;
	/**
	* Compute the URL of a source given the the source root, the source's
	* URL, and the source map's URL.
	*/
	function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
		sourceURL = sourceURL || "";
		if (sourceRoot) {
			if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") sourceRoot += "/";
			sourceURL = sourceRoot + sourceURL;
		}
		if (sourceMapURL) {
			var parsed = urlParse(sourceMapURL);
			if (!parsed) throw new Error("sourceMapURL could not be parsed");
			if (parsed.path) {
				var index = parsed.path.lastIndexOf("/");
				if (index >= 0) parsed.path = parsed.path.substring(0, index + 1);
			}
			sourceURL = join(urlGenerate(parsed), sourceURL);
		}
		return normalize(sourceURL);
	}
	exports.computeSourceURL = computeSourceURL;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/array-set.js
var require_array_set = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util();
	var has = Object.prototype.hasOwnProperty;
	var hasNativeMap = typeof Map !== "undefined";
	/**
	* A data structure which is a combination of an array and a set. Adding a new
	* member is O(1), testing for membership is O(1), and finding the index of an
	* element is O(1). Removing elements from the set is not supported. Only
	* strings are supported for membership.
	*/
	function ArraySet() {
		this._array = [];
		this._set = hasNativeMap ? /* @__PURE__ */ new Map() : Object.create(null);
	}
	/**
	* Static method for creating ArraySet instances from an existing array.
	*/
	ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
		var set = new ArraySet();
		for (var i = 0, len = aArray.length; i < len; i++) set.add(aArray[i], aAllowDuplicates);
		return set;
	};
	/**
	* Return how many unique items are in this ArraySet. If duplicates have been
	* added, than those do not count towards the size.
	*
	* @returns Number
	*/
	ArraySet.prototype.size = function ArraySet_size() {
		return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
	};
	/**
	* Add the given string to this set.
	*
	* @param String aStr
	*/
	ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
		var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
		var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
		var idx = this._array.length;
		if (!isDuplicate || aAllowDuplicates) this._array.push(aStr);
		if (!isDuplicate) {
			if (hasNativeMap) this._set.set(aStr, idx);
			else this._set[sStr] = idx;
		}
	};
	/**
	* Is the given string a member of this set?
	*
	* @param String aStr
	*/
	ArraySet.prototype.has = function ArraySet_has(aStr) {
		if (hasNativeMap) return this._set.has(aStr);
		else {
			var sStr = util.toSetString(aStr);
			return has.call(this._set, sStr);
		}
	};
	/**
	* What is the index of the given string in the array?
	*
	* @param String aStr
	*/
	ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
		if (hasNativeMap) {
			var idx = this._set.get(aStr);
			if (idx >= 0) return idx;
		} else {
			var sStr = util.toSetString(aStr);
			if (has.call(this._set, sStr)) return this._set[sStr];
		}
		throw new Error("\"" + aStr + "\" is not in the set.");
	};
	/**
	* What is the element at the given index?
	*
	* @param Number aIdx
	*/
	ArraySet.prototype.at = function ArraySet_at(aIdx) {
		if (aIdx >= 0 && aIdx < this._array.length) return this._array[aIdx];
		throw new Error("No element indexed by " + aIdx);
	};
	/**
	* Returns the array representation of this set (which has the proper indices
	* indicated by indexOf). Note that this is a copy of the internal array used
	* for storing the members so that no one can mess with internal state.
	*/
	ArraySet.prototype.toArray = function ArraySet_toArray() {
		return this._array.slice();
	};
	exports.ArraySet = ArraySet;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/mapping-list.js
var require_mapping_list = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util();
	/**
	* Determine whether mappingB is after mappingA with respect to generated
	* position.
	*/
	function generatedPositionAfter(mappingA, mappingB) {
		var lineA = mappingA.generatedLine;
		var lineB = mappingB.generatedLine;
		var columnA = mappingA.generatedColumn;
		var columnB = mappingB.generatedColumn;
		return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
	}
	/**
	* A data structure to provide a sorted view of accumulated mappings in a
	* performance conscious manner. It trades a neglibable overhead in general
	* case for a large speedup in case of mappings being added in order.
	*/
	function MappingList() {
		this._array = [];
		this._sorted = true;
		this._last = {
			generatedLine: -1,
			generatedColumn: 0
		};
	}
	/**
	* Iterate through internal items. This method takes the same arguments that
	* `Array.prototype.forEach` takes.
	*
	* NOTE: The order of the mappings is NOT guaranteed.
	*/
	MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
		this._array.forEach(aCallback, aThisArg);
	};
	/**
	* Add the given source mapping.
	*
	* @param Object aMapping
	*/
	MappingList.prototype.add = function MappingList_add(aMapping) {
		if (generatedPositionAfter(this._last, aMapping)) {
			this._last = aMapping;
			this._array.push(aMapping);
		} else {
			this._sorted = false;
			this._array.push(aMapping);
		}
	};
	/**
	* Returns the flat, sorted array of mappings. The mappings are sorted by
	* generated position.
	*
	* WARNING: This method returns internal data without copying, for
	* performance. The return value must NOT be mutated, and should be treated as
	* an immutable borrow. If you want to take ownership, you must make your own
	* copy.
	*/
	MappingList.prototype.toArray = function MappingList_toArray() {
		if (!this._sorted) {
			this._array.sort(util.compareByGeneratedPositionsInflated);
			this._sorted = true;
		}
		return this._array;
	};
	exports.MappingList = MappingList;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-generator.js
var require_source_map_generator = /* @__PURE__ */ __commonJSMin(((exports) => {
	var base64VLQ = require_base64_vlq();
	var util = require_util();
	var ArraySet = require_array_set().ArraySet;
	var MappingList = require_mapping_list().MappingList;
	/**
	* An instance of the SourceMapGenerator represents a source map which is
	* being built incrementally. You may pass an object with the following
	* properties:
	*
	*   - file: The filename of the generated source.
	*   - sourceRoot: A root for all relative URLs in this source map.
	*/
	function SourceMapGenerator(aArgs) {
		if (!aArgs) aArgs = {};
		this._file = util.getArg(aArgs, "file", null);
		this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
		this._skipValidation = util.getArg(aArgs, "skipValidation", false);
		this._sources = new ArraySet();
		this._names = new ArraySet();
		this._mappings = new MappingList();
		this._sourcesContents = null;
	}
	SourceMapGenerator.prototype._version = 3;
	/**
	* Creates a new SourceMapGenerator based on a SourceMapConsumer
	*
	* @param aSourceMapConsumer The SourceMap.
	*/
	SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
		var sourceRoot = aSourceMapConsumer.sourceRoot;
		var generator = new SourceMapGenerator({
			file: aSourceMapConsumer.file,
			sourceRoot
		});
		aSourceMapConsumer.eachMapping(function(mapping) {
			var newMapping = { generated: {
				line: mapping.generatedLine,
				column: mapping.generatedColumn
			} };
			if (mapping.source != null) {
				newMapping.source = mapping.source;
				if (sourceRoot != null) newMapping.source = util.relative(sourceRoot, newMapping.source);
				newMapping.original = {
					line: mapping.originalLine,
					column: mapping.originalColumn
				};
				if (mapping.name != null) newMapping.name = mapping.name;
			}
			generator.addMapping(newMapping);
		});
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var sourceRelative = sourceFile;
			if (sourceRoot !== null) sourceRelative = util.relative(sourceRoot, sourceFile);
			if (!generator._sources.has(sourceRelative)) generator._sources.add(sourceRelative);
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) generator.setSourceContent(sourceFile, content);
		});
		return generator;
	};
	/**
	* Add a single mapping from original source line and column to the generated
	* source's line and column for this source map being created. The mapping
	* object should have the following properties:
	*
	*   - generated: An object with the generated line and column positions.
	*   - original: An object with the original line and column positions.
	*   - source: The original source file (relative to the sourceRoot).
	*   - name: An optional original token name for this mapping.
	*/
	SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
		var generated = util.getArg(aArgs, "generated");
		var original = util.getArg(aArgs, "original", null);
		var source = util.getArg(aArgs, "source", null);
		var name = util.getArg(aArgs, "name", null);
		if (!this._skipValidation) this._validateMapping(generated, original, source, name);
		if (source != null) {
			source = String(source);
			if (!this._sources.has(source)) this._sources.add(source);
		}
		if (name != null) {
			name = String(name);
			if (!this._names.has(name)) this._names.add(name);
		}
		this._mappings.add({
			generatedLine: generated.line,
			generatedColumn: generated.column,
			originalLine: original != null && original.line,
			originalColumn: original != null && original.column,
			source,
			name
		});
	};
	/**
	* Set the source content for a source file.
	*/
	SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
		var source = aSourceFile;
		if (this._sourceRoot != null) source = util.relative(this._sourceRoot, source);
		if (aSourceContent != null) {
			if (!this._sourcesContents) this._sourcesContents = Object.create(null);
			this._sourcesContents[util.toSetString(source)] = aSourceContent;
		} else if (this._sourcesContents) {
			delete this._sourcesContents[util.toSetString(source)];
			if (Object.keys(this._sourcesContents).length === 0) this._sourcesContents = null;
		}
	};
	/**
	* Applies the mappings of a sub-source-map for a specific source file to the
	* source map being generated. Each mapping to the supplied source file is
	* rewritten using the supplied source map. Note: The resolution for the
	* resulting mappings is the minimium of this map and the supplied map.
	*
	* @param aSourceMapConsumer The source map to be applied.
	* @param aSourceFile Optional. The filename of the source file.
	*        If omitted, SourceMapConsumer's file property will be used.
	* @param aSourceMapPath Optional. The dirname of the path to the source map
	*        to be applied. If relative, it is relative to the SourceMapConsumer.
	*        This parameter is needed when the two source maps aren't in the same
	*        directory, and the source map to be applied contains relative source
	*        paths. If so, those relative source paths need to be rewritten
	*        relative to the SourceMapGenerator.
	*/
	SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
		var sourceFile = aSourceFile;
		if (aSourceFile == null) {
			if (aSourceMapConsumer.file == null) throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's \"file\" property. Both were omitted.");
			sourceFile = aSourceMapConsumer.file;
		}
		var sourceRoot = this._sourceRoot;
		if (sourceRoot != null) sourceFile = util.relative(sourceRoot, sourceFile);
		var newSources = new ArraySet();
		var newNames = new ArraySet();
		this._mappings.unsortedForEach(function(mapping) {
			if (mapping.source === sourceFile && mapping.originalLine != null) {
				var original = aSourceMapConsumer.originalPositionFor({
					line: mapping.originalLine,
					column: mapping.originalColumn
				});
				if (original.source != null) {
					mapping.source = original.source;
					if (aSourceMapPath != null) mapping.source = util.join(aSourceMapPath, mapping.source);
					if (sourceRoot != null) mapping.source = util.relative(sourceRoot, mapping.source);
					mapping.originalLine = original.line;
					mapping.originalColumn = original.column;
					if (original.name != null) mapping.name = original.name;
				}
			}
			var source = mapping.source;
			if (source != null && !newSources.has(source)) newSources.add(source);
			var name = mapping.name;
			if (name != null && !newNames.has(name)) newNames.add(name);
		}, this);
		this._sources = newSources;
		this._names = newNames;
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) {
				if (aSourceMapPath != null) sourceFile = util.join(aSourceMapPath, sourceFile);
				if (sourceRoot != null) sourceFile = util.relative(sourceRoot, sourceFile);
				this.setSourceContent(sourceFile, content);
			}
		}, this);
	};
	/**
	* A mapping can have one of the three levels of data:
	*
	*   1. Just the generated position.
	*   2. The Generated position, original position, and original source.
	*   3. Generated and original position, original source, as well as a name
	*      token.
	*
	* To maintain consistency, we validate that any new mapping being added falls
	* in to one of these categories.
	*/
	SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
		if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") throw new Error("original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.");
		if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) return;
		else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) return;
		else throw new Error("Invalid mapping: " + JSON.stringify({
			generated: aGenerated,
			source: aSource,
			original: aOriginal,
			name: aName
		}));
	};
	/**
	* Serialize the accumulated mappings in to the stream of base 64 VLQs
	* specified by the source map format.
	*/
	SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
		var previousGeneratedColumn = 0;
		var previousGeneratedLine = 1;
		var previousOriginalColumn = 0;
		var previousOriginalLine = 0;
		var previousName = 0;
		var previousSource = 0;
		var result = "";
		var next;
		var mapping;
		var nameIdx;
		var sourceIdx;
		var mappings = this._mappings.toArray();
		for (var i = 0, len = mappings.length; i < len; i++) {
			mapping = mappings[i];
			next = "";
			if (mapping.generatedLine !== previousGeneratedLine) {
				previousGeneratedColumn = 0;
				while (mapping.generatedLine !== previousGeneratedLine) {
					next += ";";
					previousGeneratedLine++;
				}
			} else if (i > 0) {
				if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) continue;
				next += ",";
			}
			next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
			previousGeneratedColumn = mapping.generatedColumn;
			if (mapping.source != null) {
				sourceIdx = this._sources.indexOf(mapping.source);
				next += base64VLQ.encode(sourceIdx - previousSource);
				previousSource = sourceIdx;
				next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
				previousOriginalLine = mapping.originalLine - 1;
				next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
				previousOriginalColumn = mapping.originalColumn;
				if (mapping.name != null) {
					nameIdx = this._names.indexOf(mapping.name);
					next += base64VLQ.encode(nameIdx - previousName);
					previousName = nameIdx;
				}
			}
			result += next;
		}
		return result;
	};
	SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
		return aSources.map(function(source) {
			if (!this._sourcesContents) return null;
			if (aSourceRoot != null) source = util.relative(aSourceRoot, source);
			var key = util.toSetString(source);
			return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
		}, this);
	};
	/**
	* Externalize the source map.
	*/
	SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
		var map = {
			version: this._version,
			sources: this._sources.toArray(),
			names: this._names.toArray(),
			mappings: this._serializeMappings()
		};
		if (this._file != null) map.file = this._file;
		if (this._sourceRoot != null) map.sourceRoot = this._sourceRoot;
		if (this._sourcesContents) map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
		return map;
	};
	/**
	* Render the source map being generated to a string.
	*/
	SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
		return JSON.stringify(this.toJSON());
	};
	exports.SourceMapGenerator = SourceMapGenerator;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/binary-search.js
var require_binary_search = /* @__PURE__ */ __commonJSMin(((exports) => {
	exports.GREATEST_LOWER_BOUND = 1;
	exports.LEAST_UPPER_BOUND = 2;
	/**
	* Recursive implementation of binary search.
	*
	* @param aLow Indices here and lower do not contain the needle.
	* @param aHigh Indices here and higher do not contain the needle.
	* @param aNeedle The element being searched for.
	* @param aHaystack The non-empty array being searched.
	* @param aCompare Function which takes two elements and returns -1, 0, or 1.
	* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
	*     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*/
	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
		var mid = Math.floor((aHigh - aLow) / 2) + aLow;
		var cmp = aCompare(aNeedle, aHaystack[mid], true);
		if (cmp === 0) return mid;
		else if (cmp > 0) {
			if (aHigh - mid > 1) return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
			if (aBias == exports.LEAST_UPPER_BOUND) return aHigh < aHaystack.length ? aHigh : -1;
			else return mid;
		} else {
			if (mid - aLow > 1) return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
			if (aBias == exports.LEAST_UPPER_BOUND) return mid;
			else return aLow < 0 ? -1 : aLow;
		}
	}
	/**
	* This is an implementation of binary search which will always try and return
	* the index of the closest element if there is no exact hit. This is because
	* mappings between original and generated line/col pairs are single points,
	* and there is an implicit region between each of them, so a miss just means
	* that you aren't on the very start of a region.
	*
	* @param aNeedle The element you are looking for.
	* @param aHaystack The array that is being searched.
	* @param aCompare A function which takes the needle and an element in the
	*     array and returns -1, 0, or 1 depending on whether the needle is less
	*     than, equal to, or greater than the element, respectively.
	* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
	*     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
	*/
	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
		if (aHaystack.length === 0) return -1;
		var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
		if (index < 0) return -1;
		while (index - 1 >= 0) {
			if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) break;
			--index;
		}
		return index;
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/quick-sort.js
var require_quick_sort = /* @__PURE__ */ __commonJSMin(((exports) => {
	/**
	* Swap the elements indexed by `x` and `y` in the array `ary`.
	*
	* @param {Array} ary
	*        The array.
	* @param {Number} x
	*        The index of the first item.
	* @param {Number} y
	*        The index of the second item.
	*/
	function swap(ary, x, y) {
		var temp = ary[x];
		ary[x] = ary[y];
		ary[y] = temp;
	}
	/**
	* Returns a random integer within the range `low .. high` inclusive.
	*
	* @param {Number} low
	*        The lower bound on the range.
	* @param {Number} high
	*        The upper bound on the range.
	*/
	function randomIntInRange(low, high) {
		return Math.round(low + Math.random() * (high - low));
	}
	/**
	* The Quick Sort algorithm.
	*
	* @param {Array} ary
	*        An array to sort.
	* @param {function} comparator
	*        Function to use to compare two items.
	* @param {Number} p
	*        Start index of the array
	* @param {Number} r
	*        End index of the array
	*/
	function doQuickSort(ary, comparator, p, r) {
		if (p < r) {
			var pivotIndex = randomIntInRange(p, r);
			var i = p - 1;
			swap(ary, pivotIndex, r);
			var pivot = ary[r];
			for (var j = p; j < r; j++) if (comparator(ary[j], pivot) <= 0) {
				i += 1;
				swap(ary, i, j);
			}
			swap(ary, i + 1, j);
			var q = i + 1;
			doQuickSort(ary, comparator, p, q - 1);
			doQuickSort(ary, comparator, q + 1, r);
		}
	}
	/**
	* Sort the given array in-place with the given comparator function.
	*
	* @param {Array} ary
	*        An array to sort.
	* @param {function} comparator
	*        Function to use to compare two items.
	*/
	exports.quickSort = function(ary, comparator) {
		doQuickSort(ary, comparator, 0, ary.length - 1);
	};
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-map-consumer.js
var require_source_map_consumer = /* @__PURE__ */ __commonJSMin(((exports) => {
	var util = require_util();
	var binarySearch = require_binary_search();
	var ArraySet = require_array_set().ArraySet;
	var base64VLQ = require_base64_vlq();
	var quickSort = require_quick_sort().quickSort;
	function SourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
	}
	SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
		return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
	};
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	SourceMapConsumer.prototype._version = 3;
	SourceMapConsumer.prototype.__generatedMappings = null;
	Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
		configurable: true,
		enumerable: true,
		get: function() {
			if (!this.__generatedMappings) this._parseMappings(this._mappings, this.sourceRoot);
			return this.__generatedMappings;
		}
	});
	SourceMapConsumer.prototype.__originalMappings = null;
	Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
		configurable: true,
		enumerable: true,
		get: function() {
			if (!this.__originalMappings) this._parseMappings(this._mappings, this.sourceRoot);
			return this.__originalMappings;
		}
	});
	SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
		var c = aStr.charAt(index);
		return c === ";" || c === ",";
	};
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		throw new Error("Subclasses must implement _parseMappings");
	};
	SourceMapConsumer.GENERATED_ORDER = 1;
	SourceMapConsumer.ORIGINAL_ORDER = 2;
	SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
	SourceMapConsumer.LEAST_UPPER_BOUND = 2;
	/**
	* Iterate over each mapping between an original source/line/column and a
	* generated line/column in this source map.
	*
	* @param Function aCallback
	*        The function that is called with each mapping.
	* @param Object aContext
	*        Optional. If specified, this object will be the value of `this` every
	*        time that `aCallback` is called.
	* @param aOrder
	*        Either `SourceMapConsumer.GENERATED_ORDER` or
	*        `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
	*        iterate over the mappings sorted by the generated file's line/column
	*        order or the original's source/line/column order, respectively. Defaults to
	*        `SourceMapConsumer.GENERATED_ORDER`.
	*/
	SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
		var context = aContext || null;
		var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
		var mappings;
		switch (order) {
			case SourceMapConsumer.GENERATED_ORDER:
				mappings = this._generatedMappings;
				break;
			case SourceMapConsumer.ORIGINAL_ORDER:
				mappings = this._originalMappings;
				break;
			default: throw new Error("Unknown order of iteration.");
		}
		var sourceRoot = this.sourceRoot;
		mappings.map(function(mapping) {
			var source = mapping.source === null ? null : this._sources.at(mapping.source);
			source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
			return {
				source,
				generatedLine: mapping.generatedLine,
				generatedColumn: mapping.generatedColumn,
				originalLine: mapping.originalLine,
				originalColumn: mapping.originalColumn,
				name: mapping.name === null ? null : this._names.at(mapping.name)
			};
		}, this).forEach(aCallback, context);
	};
	/**
	* Returns all generated line and column information for the original source,
	* line, and column provided. If no column is provided, returns all mappings
	* corresponding to a either the line we are searching for or the next
	* closest line that has any mappings. Otherwise, returns all mappings
	* corresponding to the given line and either the column we are searching for
	* or the next closest column that has any offsets.
	*
	* The only argument is an object with the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number is 1-based.
	*   - column: Optional. the column number in the original source.
	*    The column number is 0-based.
	*
	* and an array of objects is returned, each with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*    line number is 1-based.
	*   - column: The column number in the generated source, or null.
	*    The column number is 0-based.
	*/
	SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
		var line = util.getArg(aArgs, "line");
		var needle = {
			source: util.getArg(aArgs, "source"),
			originalLine: line,
			originalColumn: util.getArg(aArgs, "column", 0)
		};
		needle.source = this._findSourceIndex(needle.source);
		if (needle.source < 0) return [];
		var mappings = [];
		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
		if (index >= 0) {
			var mapping = this._originalMappings[index];
			if (aArgs.column === void 0) {
				var originalLine = mapping.originalLine;
				while (mapping && mapping.originalLine === originalLine) {
					mappings.push({
						line: util.getArg(mapping, "generatedLine", null),
						column: util.getArg(mapping, "generatedColumn", null),
						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
					});
					mapping = this._originalMappings[++index];
				}
			} else {
				var originalColumn = mapping.originalColumn;
				while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
					mappings.push({
						line: util.getArg(mapping, "generatedLine", null),
						column: util.getArg(mapping, "generatedColumn", null),
						lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
					});
					mapping = this._originalMappings[++index];
				}
			}
		}
		return mappings;
	};
	exports.SourceMapConsumer = SourceMapConsumer;
	/**
	* A BasicSourceMapConsumer instance represents a parsed source map which we can
	* query for information about the original file positions by giving it a file
	* position in the generated source.
	*
	* The first parameter is the raw source map (either as a JSON string, or
	* already parsed to an object). According to the spec, source maps have the
	* following attributes:
	*
	*   - version: Which version of the source map spec this map is following.
	*   - sources: An array of URLs to the original source files.
	*   - names: An array of identifiers which can be referrenced by individual mappings.
	*   - sourceRoot: Optional. The URL root from which all sources are relative.
	*   - sourcesContent: Optional. An array of contents of the original source files.
	*   - mappings: A string of base64 VLQs which contain the actual mappings.
	*   - file: Optional. The generated file this source map is associated with.
	*
	* Here is an example source map, taken from the source map spec[0]:
	*
	*     {
	*       version : 3,
	*       file: "out.js",
	*       sourceRoot : "",
	*       sources: ["foo.js", "bar.js"],
	*       names: ["src", "maps", "are", "fun"],
	*       mappings: "AA,AB;;ABCDE;"
	*     }
	*
	* The second parameter, if given, is a string whose value is the URL
	* at which the source map was found.  This URL is used to compute the
	* sources array.
	*
	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
	*/
	function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		var version = util.getArg(sourceMap, "version");
		var sources = util.getArg(sourceMap, "sources");
		var names = util.getArg(sourceMap, "names", []);
		var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
		var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
		var mappings = util.getArg(sourceMap, "mappings");
		var file = util.getArg(sourceMap, "file", null);
		if (version != this._version) throw new Error("Unsupported version: " + version);
		if (sourceRoot) sourceRoot = util.normalize(sourceRoot);
		sources = sources.map(String).map(util.normalize).map(function(source) {
			return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
		});
		this._names = ArraySet.fromArray(names.map(String), true);
		this._sources = ArraySet.fromArray(sources, true);
		this._absoluteSources = this._sources.toArray().map(function(s) {
			return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
		});
		this.sourceRoot = sourceRoot;
		this.sourcesContent = sourcesContent;
		this._mappings = mappings;
		this._sourceMapURL = aSourceMapURL;
		this.file = file;
	}
	BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
	BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
	/**
	* Utility function to find the index of a source.  Returns -1 if not
	* found.
	*/
	BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
		var relativeSource = aSource;
		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
		if (this._sources.has(relativeSource)) return this._sources.indexOf(relativeSource);
		var i;
		for (i = 0; i < this._absoluteSources.length; ++i) if (this._absoluteSources[i] == aSource) return i;
		return -1;
	};
	/**
	* Create a BasicSourceMapConsumer from a SourceMapGenerator.
	*
	* @param SourceMapGenerator aSourceMap
	*        The source map that will be consumed.
	* @param String aSourceMapURL
	*        The URL at which the source map can be found (optional)
	* @returns BasicSourceMapConsumer
	*/
	BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
		var smc = Object.create(BasicSourceMapConsumer.prototype);
		var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
		var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
		smc.sourceRoot = aSourceMap._sourceRoot;
		smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
		smc.file = aSourceMap._file;
		smc._sourceMapURL = aSourceMapURL;
		smc._absoluteSources = smc._sources.toArray().map(function(s) {
			return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
		});
		var generatedMappings = aSourceMap._mappings.toArray().slice();
		var destGeneratedMappings = smc.__generatedMappings = [];
		var destOriginalMappings = smc.__originalMappings = [];
		for (var i = 0, length = generatedMappings.length; i < length; i++) {
			var srcMapping = generatedMappings[i];
			var destMapping = new Mapping();
			destMapping.generatedLine = srcMapping.generatedLine;
			destMapping.generatedColumn = srcMapping.generatedColumn;
			if (srcMapping.source) {
				destMapping.source = sources.indexOf(srcMapping.source);
				destMapping.originalLine = srcMapping.originalLine;
				destMapping.originalColumn = srcMapping.originalColumn;
				if (srcMapping.name) destMapping.name = names.indexOf(srcMapping.name);
				destOriginalMappings.push(destMapping);
			}
			destGeneratedMappings.push(destMapping);
		}
		quickSort(smc.__originalMappings, util.compareByOriginalPositions);
		return smc;
	};
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	BasicSourceMapConsumer.prototype._version = 3;
	/**
	* The list of original sources.
	*/
	Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", { get: function() {
		return this._absoluteSources.slice();
	} });
	/**
	* Provide the JIT with a nice shape / hidden class.
	*/
	function Mapping() {
		this.generatedLine = 0;
		this.generatedColumn = 0;
		this.source = null;
		this.originalLine = null;
		this.originalColumn = null;
		this.name = null;
	}
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		var generatedLine = 1;
		var previousGeneratedColumn = 0;
		var previousOriginalLine = 0;
		var previousOriginalColumn = 0;
		var previousSource = 0;
		var previousName = 0;
		var length = aStr.length;
		var index = 0;
		var cachedSegments = {};
		var temp = {};
		var originalMappings = [];
		var generatedMappings = [];
		var mapping, str, segment, end, value;
		while (index < length) if (aStr.charAt(index) === ";") {
			generatedLine++;
			index++;
			previousGeneratedColumn = 0;
		} else if (aStr.charAt(index) === ",") index++;
		else {
			mapping = new Mapping();
			mapping.generatedLine = generatedLine;
			for (end = index; end < length; end++) if (this._charIsMappingSeparator(aStr, end)) break;
			str = aStr.slice(index, end);
			segment = cachedSegments[str];
			if (segment) index += str.length;
			else {
				segment = [];
				while (index < end) {
					base64VLQ.decode(aStr, index, temp);
					value = temp.value;
					index = temp.rest;
					segment.push(value);
				}
				if (segment.length === 2) throw new Error("Found a source, but no line and column");
				if (segment.length === 3) throw new Error("Found a source and line, but no column");
				cachedSegments[str] = segment;
			}
			mapping.generatedColumn = previousGeneratedColumn + segment[0];
			previousGeneratedColumn = mapping.generatedColumn;
			if (segment.length > 1) {
				mapping.source = previousSource + segment[1];
				previousSource += segment[1];
				mapping.originalLine = previousOriginalLine + segment[2];
				previousOriginalLine = mapping.originalLine;
				mapping.originalLine += 1;
				mapping.originalColumn = previousOriginalColumn + segment[3];
				previousOriginalColumn = mapping.originalColumn;
				if (segment.length > 4) {
					mapping.name = previousName + segment[4];
					previousName += segment[4];
				}
			}
			generatedMappings.push(mapping);
			if (typeof mapping.originalLine === "number") originalMappings.push(mapping);
		}
		quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
		this.__generatedMappings = generatedMappings;
		quickSort(originalMappings, util.compareByOriginalPositions);
		this.__originalMappings = originalMappings;
	};
	/**
	* Find the mapping that best matches the hypothetical "needle" mapping that
	* we are searching for in the given "haystack" of mappings.
	*/
	BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
		if (aNeedle[aLineName] <= 0) throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
		if (aNeedle[aColumnName] < 0) throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
		return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
	};
	/**
	* Compute the last column for each generated mapping. The last column is
	* inclusive.
	*/
	BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
		for (var index = 0; index < this._generatedMappings.length; ++index) {
			var mapping = this._generatedMappings[index];
			if (index + 1 < this._generatedMappings.length) {
				var nextMapping = this._generatedMappings[index + 1];
				if (mapping.generatedLine === nextMapping.generatedLine) {
					mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
					continue;
				}
			}
			mapping.lastGeneratedColumn = Infinity;
		}
	};
	/**
	* Returns the original source, line, and column information for the generated
	* source's line and column positions provided. The only argument is an object
	* with the following properties:
	*
	*   - line: The line number in the generated source.  The line number
	*     is 1-based.
	*   - column: The column number in the generated source.  The column
	*     number is 0-based.
	*   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
	*     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
	*
	* and an object is returned with the following properties:
	*
	*   - source: The original source file, or null.
	*   - line: The line number in the original source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the original source, or null.  The
	*     column number is 0-based.
	*   - name: The original identifier, or null.
	*/
	BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
		var needle = {
			generatedLine: util.getArg(aArgs, "line"),
			generatedColumn: util.getArg(aArgs, "column")
		};
		var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
		if (index >= 0) {
			var mapping = this._generatedMappings[index];
			if (mapping.generatedLine === needle.generatedLine) {
				var source = util.getArg(mapping, "source", null);
				if (source !== null) {
					source = this._sources.at(source);
					source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
				}
				var name = util.getArg(mapping, "name", null);
				if (name !== null) name = this._names.at(name);
				return {
					source,
					line: util.getArg(mapping, "originalLine", null),
					column: util.getArg(mapping, "originalColumn", null),
					name
				};
			}
		}
		return {
			source: null,
			line: null,
			column: null,
			name: null
		};
	};
	/**
	* Return true if we have the source content for every source in the source
	* map, false otherwise.
	*/
	BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
		if (!this.sourcesContent) return false;
		return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
			return sc == null;
		});
	};
	/**
	* Returns the original source content. The only argument is the url of the
	* original source file. Returns null if no original source content is
	* available.
	*/
	BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
		if (!this.sourcesContent) return null;
		var index = this._findSourceIndex(aSource);
		if (index >= 0) return this.sourcesContent[index];
		var relativeSource = aSource;
		if (this.sourceRoot != null) relativeSource = util.relative(this.sourceRoot, relativeSource);
		var url;
		if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
			var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
			if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
			if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
		}
		if (nullOnMissing) return null;
		else throw new Error("\"" + relativeSource + "\" is not in the SourceMap.");
	};
	/**
	* Returns the generated line and column information for the original source,
	* line, and column positions provided. The only argument is an object with
	* the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number
	*     is 1-based.
	*   - column: The column number in the original source.  The column
	*     number is 0-based.
	*   - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
	*     'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
	*     closest element that is smaller than or greater than the one we are
	*     searching for, respectively, if the exact element cannot be found.
	*     Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
	*
	* and an object is returned with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the generated source, or null.
	*     The column number is 0-based.
	*/
	BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
		var source = util.getArg(aArgs, "source");
		source = this._findSourceIndex(source);
		if (source < 0) return {
			line: null,
			column: null,
			lastColumn: null
		};
		var needle = {
			source,
			originalLine: util.getArg(aArgs, "line"),
			originalColumn: util.getArg(aArgs, "column")
		};
		var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
		if (index >= 0) {
			var mapping = this._originalMappings[index];
			if (mapping.source === needle.source) return {
				line: util.getArg(mapping, "generatedLine", null),
				column: util.getArg(mapping, "generatedColumn", null),
				lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
			};
		}
		return {
			line: null,
			column: null,
			lastColumn: null
		};
	};
	exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
	/**
	* An IndexedSourceMapConsumer instance represents a parsed source map which
	* we can query for information. It differs from BasicSourceMapConsumer in
	* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
	* input.
	*
	* The first parameter is a raw source map (either as a JSON string, or already
	* parsed to an object). According to the spec for indexed source maps, they
	* have the following attributes:
	*
	*   - version: Which version of the source map spec this map is following.
	*   - file: Optional. The generated file this source map is associated with.
	*   - sections: A list of section definitions.
	*
	* Each value under the "sections" field has two fields:
	*   - offset: The offset into the original specified at which this section
	*       begins to apply, defined as an object with a "line" and "column"
	*       field.
	*   - map: A source map definition. This source map could also be indexed,
	*       but doesn't have to be.
	*
	* Instead of the "map" field, it's also possible to have a "url" field
	* specifying a URL to retrieve a source map from, but that's currently
	* unsupported.
	*
	* Here's an example source map, taken from the source map spec[0], but
	* modified to omit a section which uses the "url" field.
	*
	*  {
	*    version : 3,
	*    file: "app.js",
	*    sections: [{
	*      offset: {line:100, column:10},
	*      map: {
	*        version : 3,
	*        file: "section.js",
	*        sources: ["foo.js", "bar.js"],
	*        names: ["src", "maps", "are", "fun"],
	*        mappings: "AAAA,E;;ABCDE;"
	*      }
	*    }],
	*  }
	*
	* The second parameter, if given, is a string whose value is the URL
	* at which the source map was found.  This URL is used to compute the
	* sources array.
	*
	* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
	*/
	function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
		var sourceMap = aSourceMap;
		if (typeof aSourceMap === "string") sourceMap = util.parseSourceMapInput(aSourceMap);
		var version = util.getArg(sourceMap, "version");
		var sections = util.getArg(sourceMap, "sections");
		if (version != this._version) throw new Error("Unsupported version: " + version);
		this._sources = new ArraySet();
		this._names = new ArraySet();
		var lastOffset = {
			line: -1,
			column: 0
		};
		this._sections = sections.map(function(s) {
			if (s.url) throw new Error("Support for url field in sections not implemented.");
			var offset = util.getArg(s, "offset");
			var offsetLine = util.getArg(offset, "line");
			var offsetColumn = util.getArg(offset, "column");
			if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) throw new Error("Section offsets must be ordered and non-overlapping.");
			lastOffset = offset;
			return {
				generatedOffset: {
					generatedLine: offsetLine + 1,
					generatedColumn: offsetColumn + 1
				},
				consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
			};
		});
	}
	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
	IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
	/**
	* The version of the source mapping spec that we are consuming.
	*/
	IndexedSourceMapConsumer.prototype._version = 3;
	/**
	* The list of original sources.
	*/
	Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", { get: function() {
		var sources = [];
		for (var i = 0; i < this._sections.length; i++) for (var j = 0; j < this._sections[i].consumer.sources.length; j++) sources.push(this._sections[i].consumer.sources[j]);
		return sources;
	} });
	/**
	* Returns the original source, line, and column information for the generated
	* source's line and column positions provided. The only argument is an object
	* with the following properties:
	*
	*   - line: The line number in the generated source.  The line number
	*     is 1-based.
	*   - column: The column number in the generated source.  The column
	*     number is 0-based.
	*
	* and an object is returned with the following properties:
	*
	*   - source: The original source file, or null.
	*   - line: The line number in the original source, or null.  The
	*     line number is 1-based.
	*   - column: The column number in the original source, or null.  The
	*     column number is 0-based.
	*   - name: The original identifier, or null.
	*/
	IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
		var needle = {
			generatedLine: util.getArg(aArgs, "line"),
			generatedColumn: util.getArg(aArgs, "column")
		};
		var sectionIndex = binarySearch.search(needle, this._sections, function(needle, section) {
			var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
			if (cmp) return cmp;
			return needle.generatedColumn - section.generatedOffset.generatedColumn;
		});
		var section = this._sections[sectionIndex];
		if (!section) return {
			source: null,
			line: null,
			column: null,
			name: null
		};
		return section.consumer.originalPositionFor({
			line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
			column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
			bias: aArgs.bias
		});
	};
	/**
	* Return true if we have the source content for every source in the source
	* map, false otherwise.
	*/
	IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
		return this._sections.every(function(s) {
			return s.consumer.hasContentsOfAllSources();
		});
	};
	/**
	* Returns the original source content. The only argument is the url of the
	* original source file. Returns null if no original source content is
	* available.
	*/
	IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
		for (var i = 0; i < this._sections.length; i++) {
			var content = this._sections[i].consumer.sourceContentFor(aSource, true);
			if (content) return content;
		}
		if (nullOnMissing) return null;
		else throw new Error("\"" + aSource + "\" is not in the SourceMap.");
	};
	/**
	* Returns the generated line and column information for the original source,
	* line, and column positions provided. The only argument is an object with
	* the following properties:
	*
	*   - source: The filename of the original source.
	*   - line: The line number in the original source.  The line number
	*     is 1-based.
	*   - column: The column number in the original source.  The column
	*     number is 0-based.
	*
	* and an object is returned with the following properties:
	*
	*   - line: The line number in the generated source, or null.  The
	*     line number is 1-based. 
	*   - column: The column number in the generated source, or null.
	*     The column number is 0-based.
	*/
	IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
		for (var i = 0; i < this._sections.length; i++) {
			var section = this._sections[i];
			if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) continue;
			var generatedPosition = section.consumer.generatedPositionFor(aArgs);
			if (generatedPosition) return {
				line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
				column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
			};
		}
		return {
			line: null,
			column: null
		};
	};
	/**
	* Parse the mappings in a string in to a data structure which we can easily
	* query (the ordered arrays in the `this.__generatedMappings` and
	* `this.__originalMappings` properties).
	*/
	IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
		this.__generatedMappings = [];
		this.__originalMappings = [];
		for (var i = 0; i < this._sections.length; i++) {
			var section = this._sections[i];
			var sectionMappings = section.consumer._generatedMappings;
			for (var j = 0; j < sectionMappings.length; j++) {
				var mapping = sectionMappings[j];
				var source = section.consumer._sources.at(mapping.source);
				source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
				this._sources.add(source);
				source = this._sources.indexOf(source);
				var name = null;
				if (mapping.name) {
					name = section.consumer._names.at(mapping.name);
					this._names.add(name);
					name = this._names.indexOf(name);
				}
				var adjustedMapping = {
					source,
					generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
					generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
					originalLine: mapping.originalLine,
					originalColumn: mapping.originalColumn,
					name
				};
				this.__generatedMappings.push(adjustedMapping);
				if (typeof adjustedMapping.originalLine === "number") this.__originalMappings.push(adjustedMapping);
			}
		}
		quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
		quickSort(this.__originalMappings, util.compareByOriginalPositions);
	};
	exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/lib/source-node.js
var require_source_node = /* @__PURE__ */ __commonJSMin(((exports) => {
	var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
	var util = require_util();
	var REGEX_NEWLINE = /(\r?\n)/;
	var NEWLINE_CODE = 10;
	var isSourceNode = "$$$isSourceNode$$$";
	/**
	* SourceNodes provide a way to abstract over interpolating/concatenating
	* snippets of generated JavaScript source code while maintaining the line and
	* column information associated with the original source code.
	*
	* @param aLine The original line number.
	* @param aColumn The original column number.
	* @param aSource The original source's filename.
	* @param aChunks Optional. An array of strings which are snippets of
	*        generated JS, or other SourceNodes.
	* @param aName The original identifier.
	*/
	function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
		this.children = [];
		this.sourceContents = {};
		this.line = aLine == null ? null : aLine;
		this.column = aColumn == null ? null : aColumn;
		this.source = aSource == null ? null : aSource;
		this.name = aName == null ? null : aName;
		this[isSourceNode] = true;
		if (aChunks != null) this.add(aChunks);
	}
	/**
	* Creates a SourceNode from generated code and a SourceMapConsumer.
	*
	* @param aGeneratedCode The generated code
	* @param aSourceMapConsumer The SourceMap for the generated code
	* @param aRelativePath Optional. The path that relative sources in the
	*        SourceMapConsumer should be relative to.
	*/
	SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
		var node = new SourceNode();
		var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
		var remainingLinesIndex = 0;
		var shiftNextLine = function() {
			return getNextLine() + (getNextLine() || "");
			function getNextLine() {
				return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
			}
		};
		var lastGeneratedLine = 1, lastGeneratedColumn = 0;
		var lastMapping = null;
		aSourceMapConsumer.eachMapping(function(mapping) {
			if (lastMapping !== null) {
				if (lastGeneratedLine < mapping.generatedLine) {
					addMappingWithCode(lastMapping, shiftNextLine());
					lastGeneratedLine++;
					lastGeneratedColumn = 0;
				} else {
					var nextLine = remainingLines[remainingLinesIndex] || "";
					var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
					remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
					lastGeneratedColumn = mapping.generatedColumn;
					addMappingWithCode(lastMapping, code);
					lastMapping = mapping;
					return;
				}
			}
			while (lastGeneratedLine < mapping.generatedLine) {
				node.add(shiftNextLine());
				lastGeneratedLine++;
			}
			if (lastGeneratedColumn < mapping.generatedColumn) {
				var nextLine = remainingLines[remainingLinesIndex] || "";
				node.add(nextLine.substr(0, mapping.generatedColumn));
				remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
				lastGeneratedColumn = mapping.generatedColumn;
			}
			lastMapping = mapping;
		}, this);
		if (remainingLinesIndex < remainingLines.length) {
			if (lastMapping) addMappingWithCode(lastMapping, shiftNextLine());
			node.add(remainingLines.splice(remainingLinesIndex).join(""));
		}
		aSourceMapConsumer.sources.forEach(function(sourceFile) {
			var content = aSourceMapConsumer.sourceContentFor(sourceFile);
			if (content != null) {
				if (aRelativePath != null) sourceFile = util.join(aRelativePath, sourceFile);
				node.setSourceContent(sourceFile, content);
			}
		});
		return node;
		function addMappingWithCode(mapping, code) {
			if (mapping === null || mapping.source === void 0) node.add(code);
			else {
				var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
				node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
			}
		}
	};
	/**
	* Add a chunk of generated JS to this source node.
	*
	* @param aChunk A string snippet of generated JS code, another instance of
	*        SourceNode, or an array where each member is one of those things.
	*/
	SourceNode.prototype.add = function SourceNode_add(aChunk) {
		if (Array.isArray(aChunk)) aChunk.forEach(function(chunk) {
			this.add(chunk);
		}, this);
		else if (aChunk[isSourceNode] || typeof aChunk === "string") {
			if (aChunk) this.children.push(aChunk);
		} else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
		return this;
	};
	/**
	* Add a chunk of generated JS to the beginning of this source node.
	*
	* @param aChunk A string snippet of generated JS code, another instance of
	*        SourceNode, or an array where each member is one of those things.
	*/
	SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
		if (Array.isArray(aChunk)) for (var i = aChunk.length - 1; i >= 0; i--) this.prepend(aChunk[i]);
		else if (aChunk[isSourceNode] || typeof aChunk === "string") this.children.unshift(aChunk);
		else throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
		return this;
	};
	/**
	* Walk over the tree of JS snippets in this node and its children. The
	* walking function is called once for each snippet of JS and is passed that
	* snippet and the its original associated source's line/column location.
	*
	* @param aFn The traversal function.
	*/
	SourceNode.prototype.walk = function SourceNode_walk(aFn) {
		var chunk;
		for (var i = 0, len = this.children.length; i < len; i++) {
			chunk = this.children[i];
			if (chunk[isSourceNode]) chunk.walk(aFn);
			else if (chunk !== "") aFn(chunk, {
				source: this.source,
				line: this.line,
				column: this.column,
				name: this.name
			});
		}
	};
	/**
	* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
	* each of `this.children`.
	*
	* @param aSep The separator.
	*/
	SourceNode.prototype.join = function SourceNode_join(aSep) {
		var newChildren;
		var i;
		var len = this.children.length;
		if (len > 0) {
			newChildren = [];
			for (i = 0; i < len - 1; i++) {
				newChildren.push(this.children[i]);
				newChildren.push(aSep);
			}
			newChildren.push(this.children[i]);
			this.children = newChildren;
		}
		return this;
	};
	/**
	* Call String.prototype.replace on the very right-most source snippet. Useful
	* for trimming whitespace from the end of a source node, etc.
	*
	* @param aPattern The pattern to replace.
	* @param aReplacement The thing to replace the pattern with.
	*/
	SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
		var lastChild = this.children[this.children.length - 1];
		if (lastChild[isSourceNode]) lastChild.replaceRight(aPattern, aReplacement);
		else if (typeof lastChild === "string") this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
		else this.children.push("".replace(aPattern, aReplacement));
		return this;
	};
	/**
	* Set the source content for a source file. This will be added to the SourceMapGenerator
	* in the sourcesContent field.
	*
	* @param aSourceFile The filename of the source file
	* @param aSourceContent The content of the source file
	*/
	SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
		this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
	};
	/**
	* Walk over the tree of SourceNodes. The walking function is called for each
	* source file content and is passed the filename and source content.
	*
	* @param aFn The traversal function.
	*/
	SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
		for (var i = 0, len = this.children.length; i < len; i++) if (this.children[i][isSourceNode]) this.children[i].walkSourceContents(aFn);
		var sources = Object.keys(this.sourceContents);
		for (var i = 0, len = sources.length; i < len; i++) aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
	};
	/**
	* Return the string representation of this source node. Walks over the tree
	* and concatenates all the various snippets together to one string.
	*/
	SourceNode.prototype.toString = function SourceNode_toString() {
		var str = "";
		this.walk(function(chunk) {
			str += chunk;
		});
		return str;
	};
	/**
	* Returns the string representation of this source node along with a source
	* map.
	*/
	SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
		var generated = {
			code: "",
			line: 1,
			column: 0
		};
		var map = new SourceMapGenerator(aArgs);
		var sourceMappingActive = false;
		var lastOriginalSource = null;
		var lastOriginalLine = null;
		var lastOriginalColumn = null;
		var lastOriginalName = null;
		this.walk(function(chunk, original) {
			generated.code += chunk;
			if (original.source !== null && original.line !== null && original.column !== null) {
				if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) map.addMapping({
					source: original.source,
					original: {
						line: original.line,
						column: original.column
					},
					generated: {
						line: generated.line,
						column: generated.column
					},
					name: original.name
				});
				lastOriginalSource = original.source;
				lastOriginalLine = original.line;
				lastOriginalColumn = original.column;
				lastOriginalName = original.name;
				sourceMappingActive = true;
			} else if (sourceMappingActive) {
				map.addMapping({ generated: {
					line: generated.line,
					column: generated.column
				} });
				lastOriginalSource = null;
				sourceMappingActive = false;
			}
			for (var idx = 0, length = chunk.length; idx < length; idx++) if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
				generated.line++;
				generated.column = 0;
				if (idx + 1 === length) {
					lastOriginalSource = null;
					sourceMappingActive = false;
				} else if (sourceMappingActive) map.addMapping({
					source: original.source,
					original: {
						line: original.line,
						column: original.column
					},
					generated: {
						line: generated.line,
						column: generated.column
					},
					name: original.name
				});
			} else generated.column++;
		});
		this.walkSourceContents(function(sourceFile, sourceContent) {
			map.setSourceContent(sourceFile, sourceContent);
		});
		return {
			code: generated.code,
			map
		};
	};
	exports.SourceNode = SourceNode;
}));
//#endregion
//#region node_modules/.pnpm/source-map@0.6.1/node_modules/source-map/source-map.js
var require_source_map = /* @__PURE__ */ __commonJSMin(((exports) => {
	exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
	exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
	exports.SourceNode = require_source_node().SourceNode;
}));
//#endregion
//#region packages/compiler-sfc/src/style/preprocessors.ts
var import_merge_source_map = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
	var sourceMap = require_source_map();
	var SourceMapConsumer = sourceMap.SourceMapConsumer;
	var SourceMapGenerator = sourceMap.SourceMapGenerator;
	module.exports = merge;
	/**
	* Merge old source map and new source map and return merged.
	* If old or new source map value is falsy, return another one as it is.
	*
	* @param {object|string} [oldMap] old source map object
	* @param {object|string} [newmap] new source map object
	* @return {object|undefined} merged source map object, or undefined when both old and new source map are undefined
	*/
	function merge(oldMap, newMap) {
		if (!oldMap) return newMap;
		if (!newMap) return oldMap;
		var oldMapConsumer = new SourceMapConsumer(oldMap);
		var newMapConsumer = new SourceMapConsumer(newMap);
		var mergedMapGenerator = new SourceMapGenerator();
		newMapConsumer.eachMapping(function(m) {
			if (m.originalLine == null) return;
			var origPosInOldMap = oldMapConsumer.originalPositionFor({
				line: m.originalLine,
				column: m.originalColumn
			});
			if (origPosInOldMap.source == null) return;
			mergedMapGenerator.addMapping({
				original: {
					line: origPosInOldMap.line,
					column: origPosInOldMap.column
				},
				generated: {
					line: m.generatedLine,
					column: m.generatedColumn
				},
				source: origPosInOldMap.source,
				name: origPosInOldMap.name
			});
		});
		[oldMapConsumer, newMapConsumer].forEach(function(consumer) {
			consumer.sources.forEach(function(sourceFile) {
				mergedMapGenerator._sources.add(sourceFile);
				var sourceContent = consumer.sourceContentFor(sourceFile);
				if (sourceContent != null) mergedMapGenerator.setSourceContent(sourceFile, sourceContent);
			});
		});
		mergedMapGenerator._sourceRoot = oldMap.sourceRoot;
		mergedMapGenerator._file = oldMap.file;
		return JSON.parse(mergedMapGenerator.toString());
	}
})))());
init_objectSpread2();
const scss = (source, map, options, load = __require) => {
	const { compileString, renderSync } = load("sass");
	const data = getSource(source, options.filename, options.additionalData);
	let css;
	let dependencies;
	let sourceMap;
	try {
		if (compileString) {
			const { pathToFileURL, fileURLToPath } = load("url");
			const result = compileString(data, _objectSpread2(_objectSpread2({}, options), {}, {
				url: pathToFileURL(options.filename),
				sourceMap: !!map
			}));
			css = result.css;
			dependencies = result.loadedUrls.map((url) => fileURLToPath(url));
			sourceMap = map ? result.sourceMap : void 0;
		} else {
			const result = renderSync(_objectSpread2(_objectSpread2({}, options), {}, {
				data,
				file: options.filename,
				outFile: options.filename,
				sourceMap: !!map
			}));
			css = result.css.toString();
			dependencies = result.stats.includedFiles;
			sourceMap = map ? JSON.parse(result.map.toString()) : void 0;
		}
		if (map) return {
			code: css,
			errors: [],
			dependencies,
			map: (0, import_merge_source_map.default)(map, sourceMap)
		};
		return {
			code: css,
			errors: [],
			dependencies
		};
	} catch (e) {
		return {
			code: "",
			errors: [e],
			dependencies: []
		};
	}
};
const sass = (source, map, options, load) => scss(source, map, _objectSpread2(_objectSpread2({}, options), {}, { indentedSyntax: true }), load);
const less = (source, map, options, load = __require) => {
	const nodeLess = load("less");
	let result;
	let error = null;
	nodeLess.render(getSource(source, options.filename, options.additionalData), _objectSpread2(_objectSpread2({}, options), {}, { syncImport: true }), (err, output) => {
		error = err;
		result = output;
	});
	if (error) return {
		code: "",
		errors: [error],
		dependencies: []
	};
	const dependencies = result.imports;
	if (map) return {
		code: result.css.toString(),
		map: (0, import_merge_source_map.default)(map, result.map),
		errors: [],
		dependencies
	};
	return {
		code: result.css.toString(),
		errors: [],
		dependencies
	};
};
const styl = (source, map, options, load = __require) => {
	const nodeStylus = load("stylus");
	try {
		const ref = nodeStylus(source, options);
		if (map) ref.set("sourcemap", {
			inline: false,
			comment: false
		});
		const result = ref.render();
		const dependencies = ref.deps();
		if (map) return {
			code: result,
			map: (0, import_merge_source_map.default)(map, ref.sourcemap),
			errors: [],
			dependencies
		};
		return {
			code: result,
			errors: [],
			dependencies
		};
	} catch (e) {
		return {
			code: "",
			errors: [e],
			dependencies: []
		};
	}
};
function getSource(source, filename, additionalData) {
	if (!additionalData) return source;
	if (isFunction$1(additionalData)) return additionalData(source, filename);
	return additionalData + source;
}
const processors = {
	less,
	sass,
	scss,
	styl,
	stylus: styl
};
//#endregion
//#region packages/compiler-sfc/src/compileStyle.ts
init_objectSpread2();
function compileStyle(options) {
	return doCompileStyle(_objectSpread2(_objectSpread2({}, options), {}, { isAsync: false }));
}
function compileStyleAsync(options) {
	return doCompileStyle(_objectSpread2(_objectSpread2({}, options), {}, { isAsync: true }));
}
function doCompileStyle(options) {
	const { filename, id, scoped = false, trim = true, isProd = false, modules = false, modulesOptions = {}, preprocessLang, postcssOptions, postcssPlugins } = options;
	const preprocessor = preprocessLang && processors[preprocessLang];
	const preProcessedSource = preprocessor && preprocess(options, preprocessor);
	const map = preProcessedSource ? preProcessedSource.map : options.inMap || options.map;
	const source = preProcessedSource ? preProcessedSource.code : options.source;
	const shortId = id.replace(/^data-v-/, "");
	const longId = `data-v-${shortId}`;
	const plugins = (postcssPlugins || []).slice();
	plugins.unshift(cssVarsPlugin({
		id: shortId,
		isProd
	}));
	if (trim) plugins.push(trimPlugin());
	if (scoped) plugins.push(scopedPlugin(longId));
	let cssModules;
	if (modules) throw new Error("[@vue/compiler-sfc] `modules` option is not supported in the browser build.");
	const postCSSOptions = _objectSpread2(_objectSpread2({}, postcssOptions), {}, {
		to: filename,
		from: filename
	});
	if (map) postCSSOptions.map = {
		inline: false,
		annotation: false,
		prev: map
	};
	let result;
	let code;
	let outMap;
	const dependencies = new Set(preProcessedSource ? preProcessedSource.dependencies : []);
	dependencies.delete(filename);
	const errors = [];
	if (preProcessedSource && preProcessedSource.errors.length) errors.push(...preProcessedSource.errors);
	const recordPlainCssDependencies = (messages) => {
		messages.forEach((msg) => {
			if (msg.type === "dependency") dependencies.add(msg.file);
		});
		return dependencies;
	};
	try {
		result = postcss_default(plugins).process(source, postCSSOptions);
		if (options.isAsync) return result.then((result) => ({
			code: result.css || "",
			map: result.map && result.map.toJSON(),
			errors,
			modules: cssModules,
			rawResult: result,
			dependencies: recordPlainCssDependencies(result.messages)
		})).catch((error) => ({
			code: "",
			map: void 0,
			errors: [...errors, error],
			rawResult: void 0,
			dependencies
		}));
		recordPlainCssDependencies(result.messages);
		code = result.css;
		outMap = result.map;
	} catch (e) {
		errors.push(e);
	}
	return {
		code: code || ``,
		map: outMap && outMap.toJSON(),
		errors,
		rawResult: result,
		dependencies
	};
}
function preprocess(options, preprocessor) {
	if (!options.preprocessCustomRequire) throw new Error("[@vue/compiler-sfc] Style preprocessing in the browser build must provide the `preprocessCustomRequire` option to return the in-browser version of the preprocessor.");
	return preprocessor(options.source, options.inMap || options.map, _objectSpread2({ filename: options.filename }, options.preprocessOptions), options.preprocessCustomRequire);
}
//#endregion
//#region packages/compiler-sfc/src/script/utils.ts
init__polyfill_node_path();
const UNKNOWN_TYPE = "Unknown";
function resolveObjectKey(node, computed) {
	switch (node.type) {
		case "StringLiteral":
		case "NumericLiteral": return String(node.value);
		case "Identifier": if (!computed) return node.name;
	}
}
function concatStrings(strs) {
	return strs.filter((s) => !!s).join(", ");
}
function isLiteralNode(node) {
	return node.type.endsWith("Literal");
}
function isCallOf(node, test) {
	return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
}
function toRuntimeTypeString(types) {
	return types.length > 1 ? `[${types.join(", ")}]` : types[0];
}
function getImportedName(specifier) {
	if (specifier.type === "ImportSpecifier") return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
	else if (specifier.type === "ImportNamespaceSpecifier") return "*";
	return "default";
}
function getId(node) {
	return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
}
function getStringLiteralKey(node) {
	return node.computed ? node.key.type === "TemplateLiteral" && !node.key.expressions.length ? node.key.quasis.map((q) => q.value.cooked).join("") : null : node.key.type === "Identifier" ? node.key.name : node.key.type === "StringLiteral" ? node.key.value : node.key.type === "NumericLiteral" ? String(node.key.value) : null;
}
const normalize = (_polyfill_node_path_default.posix || _polyfill_node_path_default).normalize;
const windowsSlashRE = /\\/g;
function normalizePath(p) {
	return normalize(p.replace(windowsSlashRE, "/"));
}
const joinPaths = (_polyfill_node_path_default.posix || _polyfill_node_path_default).join;
/**
* key may contain symbols
* e.g. onUpdate:modelValue -> "onUpdate:modelValue"
*/
const propNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~\-]/;
function getEscapedPropName(key) {
	return propNameEscapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
}
const isJS = (...langs) => langs.some((lang) => lang === "js" || lang === "jsx");
const isTS = (...langs) => langs.some((lang) => lang === "ts" || lang === "tsx");
//#endregion
//#region packages/compiler-sfc/src/script/analyzeScriptBindings.ts
/**
* Analyze bindings in normal `<script>`
* Note that `compileScriptSetup` already analyzes bindings as part of its
* compilation process so this should only be used on single `<script>` SFCs.
*/
function analyzeScriptBindings(ast) {
	for (const node of ast) if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "ObjectExpression") return analyzeBindingsFromOptions(node.declaration);
	return {};
}
function analyzeBindingsFromOptions(node) {
	const bindings = {};
	Object.defineProperty(bindings, "__isScriptSetup", {
		enumerable: false,
		value: false
	});
	for (const property of node.properties) if (property.type === "ObjectProperty" && !property.computed && property.key.type === "Identifier") {
		if (property.key.name === "props") for (const key of getObjectOrArrayExpressionKeys(property.value)) bindings[key] = "props";
		else if (property.key.name === "inject") for (const key of getObjectOrArrayExpressionKeys(property.value)) bindings[key] = "options";
		else if (property.value.type === "ObjectExpression" && (property.key.name === "computed" || property.key.name === "methods")) for (const key of getObjectExpressionKeys(property.value)) bindings[key] = "options";
	} else if (property.type === "ObjectMethod" && property.key.type === "Identifier" && (property.key.name === "setup" || property.key.name === "data")) {
		for (const bodyItem of property.body.body) if (bodyItem.type === "ReturnStatement" && bodyItem.argument && bodyItem.argument.type === "ObjectExpression") for (const key of getObjectExpressionKeys(bodyItem.argument)) bindings[key] = property.key.name === "setup" ? "setup-maybe-ref" : "data";
	}
	return bindings;
}
function getObjectExpressionKeys(node) {
	const keys = [];
	for (const prop of node.properties) {
		if (prop.type === "SpreadElement") continue;
		const key = resolveObjectKey(prop.key, prop.computed);
		if (key) keys.push(String(key));
	}
	return keys;
}
function getArrayExpressionKeys(node) {
	const keys = [];
	for (const element of node.elements) if (element && element.type === "StringLiteral") keys.push(element.value);
	return keys;
}
function getObjectOrArrayExpressionKeys(value) {
	if (value.type === "ArrayExpression") return getArrayExpressionKeys(value);
	if (value.type === "ObjectExpression") return getObjectExpressionKeys(value);
	return [];
}
//#endregion
//#region node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
init__polyfill_node_buffer();
var comma = ",".charCodeAt(0);
var semicolon = ";".charCodeAt(0);
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var intToChar = /* @__PURE__ */ new Uint8Array(64);
var charToInt = /* @__PURE__ */ new Uint8Array(128);
for (let i = 0; i < chars.length; i++) {
	const c = chars.charCodeAt(i);
	intToChar[i] = c;
	charToInt[c] = i;
}
function encodeInteger(builder, num, relative) {
	let delta = num - relative;
	delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
	do {
		let clamped = delta & 31;
		delta >>>= 5;
		if (delta > 0) clamped |= 32;
		builder.write(intToChar[clamped]);
	} while (delta > 0);
	return num;
}
var bufLength = 16384;
var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer$1 !== "undefined" ? { decode(buf) {
	return Buffer$1.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
} } : { decode(buf) {
	let out = "";
	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
	return out;
} };
var StringWriter = class {
	constructor() {
		this.pos = 0;
		this.out = "";
		this.buffer = new Uint8Array(bufLength);
	}
	write(v) {
		const { buffer } = this;
		buffer[this.pos++] = v;
		if (this.pos === bufLength) {
			this.out += td.decode(buffer);
			this.pos = 0;
		}
	}
	flush() {
		const { buffer, out, pos } = this;
		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
	}
};
function encode(decoded) {
	const writer = new StringWriter();
	let sourcesIndex = 0;
	let sourceLine = 0;
	let sourceColumn = 0;
	let namesIndex = 0;
	for (let i = 0; i < decoded.length; i++) {
		const line = decoded[i];
		if (i > 0) writer.write(semicolon);
		if (line.length === 0) continue;
		let genColumn = 0;
		for (let j = 0; j < line.length; j++) {
			const segment = line[j];
			if (j > 0) writer.write(comma);
			genColumn = encodeInteger(writer, segment[0], genColumn);
			if (segment.length === 1) continue;
			sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
			sourceLine = encodeInteger(writer, segment[2], sourceLine);
			sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
			if (segment.length === 4) continue;
			namesIndex = encodeInteger(writer, segment[4], namesIndex);
		}
	}
	return writer.flush();
}
//#endregion
//#region node_modules/.pnpm/magic-string@0.30.21/node_modules/magic-string/dist/magic-string.es.mjs
init__polyfill_node_buffer();
init_objectSpread2();
var BitSet = class BitSet {
	constructor(arg) {
		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
	}
	add(n) {
		this.bits[n >> 5] |= 1 << (n & 31);
	}
	has(n) {
		return !!(this.bits[n >> 5] & 1 << (n & 31));
	}
};
var Chunk = class Chunk {
	constructor(start, end, content) {
		this.start = start;
		this.end = end;
		this.original = content;
		this.intro = "";
		this.outro = "";
		this.content = content;
		this.storeName = false;
		this.edited = false;
		this.previous = null;
		this.next = null;
	}
	appendLeft(content) {
		this.outro += content;
	}
	appendRight(content) {
		this.intro = this.intro + content;
	}
	clone() {
		const chunk = new Chunk(this.start, this.end, this.original);
		chunk.intro = this.intro;
		chunk.outro = this.outro;
		chunk.content = this.content;
		chunk.storeName = this.storeName;
		chunk.edited = this.edited;
		return chunk;
	}
	contains(index) {
		return this.start < index && index < this.end;
	}
	eachNext(fn) {
		let chunk = this;
		while (chunk) {
			fn(chunk);
			chunk = chunk.next;
		}
	}
	eachPrevious(fn) {
		let chunk = this;
		while (chunk) {
			fn(chunk);
			chunk = chunk.previous;
		}
	}
	edit(content, storeName, contentOnly) {
		this.content = content;
		if (!contentOnly) {
			this.intro = "";
			this.outro = "";
		}
		this.storeName = storeName;
		this.edited = true;
		return this;
	}
	prependLeft(content) {
		this.outro = content + this.outro;
	}
	prependRight(content) {
		this.intro = content + this.intro;
	}
	reset() {
		this.intro = "";
		this.outro = "";
		if (this.edited) {
			this.content = this.original;
			this.storeName = false;
			this.edited = false;
		}
	}
	split(index) {
		const sliceIndex = index - this.start;
		const originalBefore = this.original.slice(0, sliceIndex);
		const originalAfter = this.original.slice(sliceIndex);
		this.original = originalBefore;
		const newChunk = new Chunk(index, this.end, originalAfter);
		newChunk.outro = this.outro;
		this.outro = "";
		this.end = index;
		if (this.edited) {
			newChunk.edit("", false);
			this.content = "";
		} else this.content = originalBefore;
		newChunk.next = this.next;
		if (newChunk.next) newChunk.next.previous = newChunk;
		newChunk.previous = this;
		this.next = newChunk;
		return newChunk;
	}
	toString() {
		return this.intro + this.content + this.outro;
	}
	trimEnd(rx) {
		this.outro = this.outro.replace(rx, "");
		if (this.outro.length) return true;
		const trimmed = this.content.replace(rx, "");
		if (trimmed.length) {
			if (trimmed !== this.content) {
				this.split(this.start + trimmed.length).edit("", void 0, true);
				if (this.edited) this.edit(trimmed, this.storeName, true);
			}
			return true;
		} else {
			this.edit("", void 0, true);
			this.intro = this.intro.replace(rx, "");
			if (this.intro.length) return true;
		}
	}
	trimStart(rx) {
		this.intro = this.intro.replace(rx, "");
		if (this.intro.length) return true;
		const trimmed = this.content.replace(rx, "");
		if (trimmed.length) {
			if (trimmed !== this.content) {
				const newChunk = this.split(this.end - trimmed.length);
				if (this.edited) newChunk.edit(trimmed, this.storeName, true);
				this.edit("", void 0, true);
			}
			return true;
		} else {
			this.edit("", void 0, true);
			this.outro = this.outro.replace(rx, "");
			if (this.outro.length) return true;
		}
	}
};
function getBtoa() {
	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
	else if (typeof Buffer$1 === "function") return (str) => Buffer$1.from(str, "utf-8").toString("base64");
	else return () => {
		throw new Error("Unsupported environment: `window.btoa` or `Buffer` should be supported.");
	};
}
const btoa = /*#__PURE__*/ getBtoa();
var SourceMap = class {
	constructor(properties) {
		this.version = 3;
		this.file = properties.file;
		this.sources = properties.sources;
		this.sourcesContent = properties.sourcesContent;
		this.names = properties.names;
		this.mappings = encode(properties.mappings);
		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
	}
	toString() {
		return JSON.stringify(this);
	}
	toUrl() {
		return "data:application/json;charset=utf-8;base64," + btoa(this.toString());
	}
};
function guessIndent(code) {
	const lines = code.split("\n");
	const tabbed = lines.filter((line) => /^\t+/.test(line));
	const spaced = lines.filter((line) => /^ {2,}/.test(line));
	if (tabbed.length === 0 && spaced.length === 0) return null;
	if (tabbed.length >= spaced.length) return "	";
	const min = spaced.reduce((previous, current) => {
		const numSpaces = /^ +/.exec(current)[0].length;
		return Math.min(numSpaces, previous);
	}, Infinity);
	return new Array(min + 1).join(" ");
}
function getRelativePath(from, to) {
	const fromParts = from.split(/[/\\]/);
	const toParts = to.split(/[/\\]/);
	fromParts.pop();
	while (fromParts[0] === toParts[0]) {
		fromParts.shift();
		toParts.shift();
	}
	if (fromParts.length) {
		let i = fromParts.length;
		while (i--) fromParts[i] = "..";
	}
	return fromParts.concat(toParts).join("/");
}
const toString = Object.prototype.toString;
function isObject(thing) {
	return toString.call(thing) === "[object Object]";
}
function getLocator(source) {
	const originalLines = source.split("\n");
	const lineOffsets = [];
	for (let i = 0, pos = 0; i < originalLines.length; i++) {
		lineOffsets.push(pos);
		pos += originalLines[i].length + 1;
	}
	return function locate(index) {
		let i = 0;
		let j = lineOffsets.length;
		while (i < j) {
			const m = i + j >> 1;
			if (index < lineOffsets[m]) j = m;
			else i = m + 1;
		}
		const line = i - 1;
		return {
			line,
			column: index - lineOffsets[line]
		};
	};
}
const wordRegex = /\w/;
var Mappings = class {
	constructor(hires) {
		this.hires = hires;
		this.generatedCodeLine = 0;
		this.generatedCodeColumn = 0;
		this.raw = [];
		this.rawSegments = this.raw[this.generatedCodeLine] = [];
		this.pending = null;
	}
	addEdit(sourceIndex, content, loc, nameIndex) {
		if (content.length) {
			const contentLengthMinusOne = content.length - 1;
			let contentLineEnd = content.indexOf("\n", 0);
			let previousContentLineEnd = -1;
			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
				const segment = [
					this.generatedCodeColumn,
					sourceIndex,
					loc.line,
					loc.column
				];
				if (nameIndex >= 0) segment.push(nameIndex);
				this.rawSegments.push(segment);
				this.generatedCodeLine += 1;
				this.raw[this.generatedCodeLine] = this.rawSegments = [];
				this.generatedCodeColumn = 0;
				previousContentLineEnd = contentLineEnd;
				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
			}
			const segment = [
				this.generatedCodeColumn,
				sourceIndex,
				loc.line,
				loc.column
			];
			if (nameIndex >= 0) segment.push(nameIndex);
			this.rawSegments.push(segment);
			this.advance(content.slice(previousContentLineEnd + 1));
		} else if (this.pending) {
			this.rawSegments.push(this.pending);
			this.advance(content);
		}
		this.pending = null;
	}
	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
		let originalCharIndex = chunk.start;
		let first = true;
		let charInHiresBoundary = false;
		while (originalCharIndex < chunk.end) {
			if (original[originalCharIndex] === "\n") {
				loc.line += 1;
				loc.column = 0;
				this.generatedCodeLine += 1;
				this.raw[this.generatedCodeLine] = this.rawSegments = [];
				this.generatedCodeColumn = 0;
				first = true;
				charInHiresBoundary = false;
			} else {
				if (this.hires || first || sourcemapLocations.has(originalCharIndex)) {
					const segment = [
						this.generatedCodeColumn,
						sourceIndex,
						loc.line,
						loc.column
					];
					if (this.hires === "boundary") {
						if (wordRegex.test(original[originalCharIndex])) {
							if (!charInHiresBoundary) {
								this.rawSegments.push(segment);
								charInHiresBoundary = true;
							}
						} else {
							this.rawSegments.push(segment);
							charInHiresBoundary = false;
						}
					} else this.rawSegments.push(segment);
				}
				loc.column += 1;
				this.generatedCodeColumn += 1;
				first = false;
			}
			originalCharIndex += 1;
		}
		this.pending = null;
	}
	advance(str) {
		if (!str) return;
		const lines = str.split("\n");
		if (lines.length > 1) {
			for (let i = 0; i < lines.length - 1; i++) {
				this.generatedCodeLine++;
				this.raw[this.generatedCodeLine] = this.rawSegments = [];
			}
			this.generatedCodeColumn = 0;
		}
		this.generatedCodeColumn += lines[lines.length - 1].length;
	}
};
const n = "\n";
const warned = {
	insertLeft: false,
	insertRight: false,
	storeName: false
};
var MagicString = class MagicString {
	constructor(string, options = {}) {
		const chunk = new Chunk(0, string.length, string);
		Object.defineProperties(this, {
			original: {
				writable: true,
				value: string
			},
			outro: {
				writable: true,
				value: ""
			},
			intro: {
				writable: true,
				value: ""
			},
			firstChunk: {
				writable: true,
				value: chunk
			},
			lastChunk: {
				writable: true,
				value: chunk
			},
			lastSearchedChunk: {
				writable: true,
				value: chunk
			},
			byStart: {
				writable: true,
				value: {}
			},
			byEnd: {
				writable: true,
				value: {}
			},
			filename: {
				writable: true,
				value: options.filename
			},
			indentExclusionRanges: {
				writable: true,
				value: options.indentExclusionRanges
			},
			sourcemapLocations: {
				writable: true,
				value: new BitSet()
			},
			storedNames: {
				writable: true,
				value: {}
			},
			indentStr: {
				writable: true,
				value: void 0
			},
			ignoreList: {
				writable: true,
				value: options.ignoreList
			},
			offset: {
				writable: true,
				value: options.offset || 0
			}
		});
		this.byStart[0] = chunk;
		this.byEnd[string.length] = chunk;
	}
	addSourcemapLocation(char) {
		this.sourcemapLocations.add(char);
	}
	append(content) {
		if (typeof content !== "string") throw new TypeError("outro content must be a string");
		this.outro += content;
		return this;
	}
	appendLeft(index, content) {
		index = index + this.offset;
		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
		this._split(index);
		const chunk = this.byEnd[index];
		if (chunk) chunk.appendLeft(content);
		else this.intro += content;
		return this;
	}
	appendRight(index, content) {
		index = index + this.offset;
		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
		this._split(index);
		const chunk = this.byStart[index];
		if (chunk) chunk.appendRight(content);
		else this.outro += content;
		return this;
	}
	clone() {
		const cloned = new MagicString(this.original, {
			filename: this.filename,
			offset: this.offset
		});
		let originalChunk = this.firstChunk;
		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
		while (originalChunk) {
			cloned.byStart[clonedChunk.start] = clonedChunk;
			cloned.byEnd[clonedChunk.end] = clonedChunk;
			const nextOriginalChunk = originalChunk.next;
			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
			if (nextClonedChunk) {
				clonedChunk.next = nextClonedChunk;
				nextClonedChunk.previous = clonedChunk;
				clonedChunk = nextClonedChunk;
			}
			originalChunk = nextOriginalChunk;
		}
		cloned.lastChunk = clonedChunk;
		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
		cloned.intro = this.intro;
		cloned.outro = this.outro;
		return cloned;
	}
	generateDecodedMap(options) {
		options = options || {};
		const sourceIndex = 0;
		const names = Object.keys(this.storedNames);
		const mappings = new Mappings(options.hires);
		const locate = getLocator(this.original);
		if (this.intro) mappings.advance(this.intro);
		this.firstChunk.eachNext((chunk) => {
			const loc = locate(chunk.start);
			if (chunk.intro.length) mappings.advance(chunk.intro);
			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
			if (chunk.outro.length) mappings.advance(chunk.outro);
		});
		if (this.outro) mappings.advance(this.outro);
		return {
			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
			sourcesContent: options.includeContent ? [this.original] : void 0,
			names,
			mappings: mappings.raw,
			x_google_ignoreList: this.ignoreList ? [sourceIndex] : void 0
		};
	}
	generateMap(options) {
		return new SourceMap(this.generateDecodedMap(options));
	}
	_ensureindentStr() {
		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
	}
	_getRawIndentString() {
		this._ensureindentStr();
		return this.indentStr;
	}
	getIndentString() {
		this._ensureindentStr();
		return this.indentStr === null ? "	" : this.indentStr;
	}
	indent(indentStr, options) {
		const pattern = /^[^\r\n]/gm;
		if (isObject(indentStr)) {
			options = indentStr;
			indentStr = void 0;
		}
		if (indentStr === void 0) {
			this._ensureindentStr();
			indentStr = this.indentStr || "	";
		}
		if (indentStr === "") return this;
		options = options || {};
		const isExcluded = {};
		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
		});
		let shouldIndentNextCharacter = options.indentStart !== false;
		const replacer = (match) => {
			if (shouldIndentNextCharacter) return `${indentStr}${match}`;
			shouldIndentNextCharacter = true;
			return match;
		};
		this.intro = this.intro.replace(pattern, replacer);
		let charIndex = 0;
		let chunk = this.firstChunk;
		while (chunk) {
			const end = chunk.end;
			if (chunk.edited) {
				if (!isExcluded[charIndex]) {
					chunk.content = chunk.content.replace(pattern, replacer);
					if (chunk.content.length) shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === "\n";
				}
			} else {
				charIndex = chunk.start;
				while (charIndex < end) {
					if (!isExcluded[charIndex]) {
						const char = this.original[charIndex];
						if (char === "\n") shouldIndentNextCharacter = true;
						else if (char !== "\r" && shouldIndentNextCharacter) {
							shouldIndentNextCharacter = false;
							if (charIndex === chunk.start) chunk.prependRight(indentStr);
							else {
								this._splitChunk(chunk, charIndex);
								chunk = chunk.next;
								chunk.prependRight(indentStr);
							}
						}
					}
					charIndex += 1;
				}
			}
			charIndex = chunk.end;
			chunk = chunk.next;
		}
		this.outro = this.outro.replace(pattern, replacer);
		return this;
	}
	insert() {
		throw new Error("magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)");
	}
	insertLeft(index, content) {
		if (!warned.insertLeft) {
			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
			warned.insertLeft = true;
		}
		return this.appendLeft(index, content);
	}
	insertRight(index, content) {
		if (!warned.insertRight) {
			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
			warned.insertRight = true;
		}
		return this.prependRight(index, content);
	}
	move(start, end, index) {
		start = start + this.offset;
		end = end + this.offset;
		index = index + this.offset;
		if (index >= start && index <= end) throw new Error("Cannot move a selection inside itself");
		this._split(start);
		this._split(end);
		this._split(index);
		const first = this.byStart[start];
		const last = this.byEnd[end];
		const oldLeft = first.previous;
		const oldRight = last.next;
		const newRight = this.byStart[index];
		if (!newRight && last === this.lastChunk) return this;
		const newLeft = newRight ? newRight.previous : this.lastChunk;
		if (oldLeft) oldLeft.next = oldRight;
		if (oldRight) oldRight.previous = oldLeft;
		if (newLeft) newLeft.next = first;
		if (newRight) newRight.previous = last;
		if (!first.previous) this.firstChunk = last.next;
		if (!last.next) {
			this.lastChunk = first.previous;
			this.lastChunk.next = null;
		}
		first.previous = newLeft;
		last.next = newRight || null;
		if (!newLeft) this.firstChunk = first;
		if (!newRight) this.lastChunk = last;
		return this;
	}
	overwrite(start, end, content, options) {
		options = options || {};
		return this.update(start, end, content, _objectSpread2(_objectSpread2({}, options), {}, { overwrite: !options.contentOnly }));
	}
	update(start, end, content, options) {
		start = start + this.offset;
		end = end + this.offset;
		if (typeof content !== "string") throw new TypeError("replacement content must be a string");
		if (this.original.length !== 0) {
			while (start < 0) start += this.original.length;
			while (end < 0) end += this.original.length;
		}
		if (end > this.original.length) throw new Error("end is out of bounds");
		if (start === end) throw new Error("Cannot overwrite a zero-length range – use appendLeft or prependRight instead");
		this._split(start);
		this._split(end);
		if (options === true) {
			if (!warned.storeName) {
				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
				warned.storeName = true;
			}
			options = { storeName: true };
		}
		const storeName = options !== void 0 ? options.storeName : false;
		const overwrite = options !== void 0 ? options.overwrite : false;
		if (storeName) {
			const original = this.original.slice(start, end);
			Object.defineProperty(this.storedNames, original, {
				writable: true,
				value: true,
				enumerable: true
			});
		}
		const first = this.byStart[start];
		const last = this.byEnd[end];
		if (first) {
			let chunk = first;
			while (chunk !== last) {
				if (chunk.next !== this.byStart[chunk.end]) throw new Error("Cannot overwrite across a split point");
				chunk = chunk.next;
				chunk.edit("", false);
			}
			first.edit(content, storeName, !overwrite);
		} else {
			const newChunk = new Chunk(start, end, "").edit(content, storeName);
			last.next = newChunk;
			newChunk.previous = last;
		}
		return this;
	}
	prepend(content) {
		if (typeof content !== "string") throw new TypeError("outro content must be a string");
		this.intro = content + this.intro;
		return this;
	}
	prependLeft(index, content) {
		index = index + this.offset;
		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
		this._split(index);
		const chunk = this.byEnd[index];
		if (chunk) chunk.prependLeft(content);
		else this.intro = content + this.intro;
		return this;
	}
	prependRight(index, content) {
		index = index + this.offset;
		if (typeof content !== "string") throw new TypeError("inserted content must be a string");
		this._split(index);
		const chunk = this.byStart[index];
		if (chunk) chunk.prependRight(content);
		else this.outro = content + this.outro;
		return this;
	}
	remove(start, end) {
		start = start + this.offset;
		end = end + this.offset;
		if (this.original.length !== 0) {
			while (start < 0) start += this.original.length;
			while (end < 0) end += this.original.length;
		}
		if (start === end) return this;
		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
		if (start > end) throw new Error("end must be greater than start");
		this._split(start);
		this._split(end);
		let chunk = this.byStart[start];
		while (chunk) {
			chunk.intro = "";
			chunk.outro = "";
			chunk.edit("");
			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
		}
		return this;
	}
	reset(start, end) {
		start = start + this.offset;
		end = end + this.offset;
		if (this.original.length !== 0) {
			while (start < 0) start += this.original.length;
			while (end < 0) end += this.original.length;
		}
		if (start === end) return this;
		if (start < 0 || end > this.original.length) throw new Error("Character is out of bounds");
		if (start > end) throw new Error("end must be greater than start");
		this._split(start);
		this._split(end);
		let chunk = this.byStart[start];
		while (chunk) {
			chunk.reset();
			chunk = end > chunk.end ? this.byStart[chunk.end] : null;
		}
		return this;
	}
	lastChar() {
		if (this.outro.length) return this.outro[this.outro.length - 1];
		let chunk = this.lastChunk;
		do {
			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
		} while (chunk = chunk.previous);
		if (this.intro.length) return this.intro[this.intro.length - 1];
		return "";
	}
	lastLine() {
		let lineIndex = this.outro.lastIndexOf(n);
		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
		let lineStr = this.outro;
		let chunk = this.lastChunk;
		do {
			if (chunk.outro.length > 0) {
				lineIndex = chunk.outro.lastIndexOf(n);
				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
				lineStr = chunk.outro + lineStr;
			}
			if (chunk.content.length > 0) {
				lineIndex = chunk.content.lastIndexOf(n);
				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
				lineStr = chunk.content + lineStr;
			}
			if (chunk.intro.length > 0) {
				lineIndex = chunk.intro.lastIndexOf(n);
				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
				lineStr = chunk.intro + lineStr;
			}
		} while (chunk = chunk.previous);
		lineIndex = this.intro.lastIndexOf(n);
		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
		return this.intro + lineStr;
	}
	slice(start = 0, end = this.original.length - this.offset) {
		start = start + this.offset;
		end = end + this.offset;
		if (this.original.length !== 0) {
			while (start < 0) start += this.original.length;
			while (end < 0) end += this.original.length;
		}
		let result = "";
		let chunk = this.firstChunk;
		while (chunk && (chunk.start > start || chunk.end <= start)) {
			if (chunk.start < end && chunk.end >= end) return result;
			chunk = chunk.next;
		}
		if (chunk && chunk.edited && chunk.start !== start) throw new Error(`Cannot use replaced character ${start} as slice start anchor.`);
		const startChunk = chunk;
		while (chunk) {
			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
			const containsEnd = chunk.start < end && chunk.end >= end;
			if (containsEnd && chunk.edited && chunk.end !== end) throw new Error(`Cannot use replaced character ${end} as slice end anchor.`);
			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
			result += chunk.content.slice(sliceStart, sliceEnd);
			if (chunk.outro && (!containsEnd || chunk.end === end)) result += chunk.outro;
			if (containsEnd) break;
			chunk = chunk.next;
		}
		return result;
	}
	snip(start, end) {
		const clone = this.clone();
		clone.remove(0, start);
		clone.remove(end, clone.original.length);
		return clone;
	}
	_split(index) {
		if (this.byStart[index] || this.byEnd[index]) return;
		let chunk = this.lastSearchedChunk;
		let previousChunk = chunk;
		const searchForward = index > chunk.end;
		while (chunk) {
			if (chunk.contains(index)) return this._splitChunk(chunk, index);
			chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start];
			if (chunk === previousChunk) return;
			previousChunk = chunk;
		}
	}
	_splitChunk(chunk, index) {
		if (chunk.edited && chunk.content.length) {
			const loc = getLocator(this.original)(index);
			throw new Error(`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
		}
		const newChunk = chunk.split(index);
		this.byEnd[index] = chunk;
		this.byStart[index] = newChunk;
		this.byEnd[newChunk.end] = newChunk;
		if (chunk === this.lastChunk) this.lastChunk = newChunk;
		this.lastSearchedChunk = chunk;
		return true;
	}
	toString() {
		let str = this.intro;
		let chunk = this.firstChunk;
		while (chunk) {
			str += chunk.toString();
			chunk = chunk.next;
		}
		return str + this.outro;
	}
	isEmpty() {
		let chunk = this.firstChunk;
		do
			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
		while (chunk = chunk.next);
		return true;
	}
	length() {
		let chunk = this.firstChunk;
		let length = 0;
		do
			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
		while (chunk = chunk.next);
		return length;
	}
	trimLines() {
		return this.trim("[\\r\\n]");
	}
	trim(charType) {
		return this.trimStart(charType).trimEnd(charType);
	}
	trimEndAborted(charType) {
		const rx = new RegExp((charType || "\\s") + "+$");
		this.outro = this.outro.replace(rx, "");
		if (this.outro.length) return true;
		let chunk = this.lastChunk;
		do {
			const end = chunk.end;
			const aborted = chunk.trimEnd(rx);
			if (chunk.end !== end) {
				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
				this.byEnd[chunk.end] = chunk;
				this.byStart[chunk.next.start] = chunk.next;
				this.byEnd[chunk.next.end] = chunk.next;
			}
			if (aborted) return true;
			chunk = chunk.previous;
		} while (chunk);
		return false;
	}
	trimEnd(charType) {
		this.trimEndAborted(charType);
		return this;
	}
	trimStartAborted(charType) {
		const rx = new RegExp("^" + (charType || "\\s") + "+");
		this.intro = this.intro.replace(rx, "");
		if (this.intro.length) return true;
		let chunk = this.firstChunk;
		do {
			const end = chunk.end;
			const aborted = chunk.trimStart(rx);
			if (chunk.end !== end) {
				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
				this.byEnd[chunk.end] = chunk;
				this.byStart[chunk.next.start] = chunk.next;
				this.byEnd[chunk.next.end] = chunk.next;
			}
			if (aborted) return true;
			chunk = chunk.next;
		} while (chunk);
		return false;
	}
	trimStart(charType) {
		this.trimStartAborted(charType);
		return this;
	}
	hasChanged() {
		return this.original !== this.toString();
	}
	_replaceRegexp(searchValue, replacement) {
		function getReplacement(match, str) {
			if (typeof replacement === "string") return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
				if (i === "$") return "$";
				if (i === "&") return match[0];
				if (+i < match.length) return match[+i];
				return `$${i}`;
			});
			else return replacement(...match, match.index, str, match.groups);
		}
		function matchAll(re, str) {
			let match;
			const matches = [];
			while (match = re.exec(str)) matches.push(match);
			return matches;
		}
		if (searchValue.global) matchAll(searchValue, this.original).forEach((match) => {
			if (match.index != null) {
				const replacement = getReplacement(match, this.original);
				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
			}
		});
		else {
			const match = this.original.match(searchValue);
			if (match && match.index != null) {
				const replacement = getReplacement(match, this.original);
				if (replacement !== match[0]) this.overwrite(match.index, match.index + match[0].length, replacement);
			}
		}
		return this;
	}
	_replaceString(string, replacement) {
		const { original } = this;
		const index = original.indexOf(string);
		if (index !== -1) {
			if (typeof replacement === "function") replacement = replacement(string, index, original);
			if (string !== replacement) this.overwrite(index, index + string.length, replacement);
		}
		return this;
	}
	replace(searchValue, replacement) {
		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
		return this._replaceRegexp(searchValue, replacement);
	}
	_replaceAllString(string, replacement) {
		const { original } = this;
		const stringLength = string.length;
		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
			const previous = original.slice(index, index + stringLength);
			let _replacement = replacement;
			if (typeof replacement === "function") _replacement = replacement(previous, index, original);
			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
		}
		return this;
	}
	replaceAll(searchValue, replacement) {
		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
		if (!searchValue.global) throw new TypeError("MagicString.prototype.replaceAll called with a non-global RegExp argument");
		return this._replaceRegexp(searchValue, replacement);
	}
};
//#endregion
//#region packages/compiler-sfc/src/script/context.ts
var ScriptCompileContext = class {
	helper(key) {
		this.helperImports.add(key);
		return `_${key}`;
	}
	constructor(descriptor, options) {
		var _descriptor$scriptSet, _descriptor$scriptSet2;
		this.descriptor = descriptor;
		this.options = options;
		this.isCE = false;
		this.userImports = Object.create(null);
		this.hasDefinePropsCall = false;
		this.hasDefineEmitCall = false;
		this.hasDefineExposeCall = false;
		this.hasDefaultExportName = false;
		this.hasDefaultExportRender = false;
		this.hasDefineOptionsCall = false;
		this.hasDefineSlotsCall = false;
		this.hasDefineModelCall = false;
		this.propsDestructuredBindings = Object.create(null);
		this.modelDecls = Object.create(null);
		this.bindingMetadata = {};
		this.helperImports = /* @__PURE__ */ new Set();
		const { script, scriptSetup } = descriptor;
		const scriptLang = script && script.lang;
		const scriptSetupLang = scriptSetup && scriptSetup.lang;
		this.source = descriptor.source;
		this.filename = descriptor.filename;
		this.s = new MagicString(descriptor.source);
		this.startOffset = (_descriptor$scriptSet = descriptor.scriptSetup) === null || _descriptor$scriptSet === void 0 ? void 0 : _descriptor$scriptSet.loc.start.offset;
		this.endOffset = (_descriptor$scriptSet2 = descriptor.scriptSetup) === null || _descriptor$scriptSet2 === void 0 ? void 0 : _descriptor$scriptSet2.loc.end.offset;
		this.isJS = isJS(scriptLang, scriptSetupLang);
		this.isTS = isTS(scriptLang, scriptSetupLang);
		const customElement = options.customElement;
		const filename = descriptor.filename;
		if (customElement) this.isCE = typeof customElement === "boolean" ? customElement : customElement(filename);
		const plugins = resolveParserPlugins(scriptLang || scriptSetupLang, options.babelParserPlugins);
		function parse(input, offset) {
			try {
				return (0, import_lib.parse)(input, {
					plugins,
					sourceType: "module"
				}).program;
			} catch (e) {
				e.message = `[vue/compiler-sfc] ${e.message}\n\n${descriptor.filename}\n${generateCodeFrame(descriptor.source, e.pos + offset, e.pos + offset + 1)}`;
				throw e;
			}
		}
		this.scriptAst = descriptor.script && parse(descriptor.script.content, descriptor.script.loc.start.offset);
		this.scriptSetupAst = descriptor.scriptSetup && parse(descriptor.scriptSetup.content, this.startOffset);
	}
	getString(node, scriptSetup = true) {
		return (scriptSetup ? this.descriptor.scriptSetup : this.descriptor.script).content.slice(node.start, node.end);
	}
	warn(msg, node, scope) {
		warn(generateError(msg, node, this, scope));
	}
	error(msg, node, scope) {
		throw new Error(`[@vue/compiler-sfc] ${generateError(msg, node, this, scope)}`);
	}
};
function generateError(msg, node, ctx, scope) {
	const offset = scope ? scope.offset : ctx.startOffset;
	return `${msg}\n\n${(scope || ctx.descriptor).filename}\n${generateCodeFrame((scope || ctx.descriptor).source, node.start + offset, node.end + offset)}`;
}
function resolveParserPlugins(lang, userPlugins, dts = false) {
	const plugins = [];
	if (!userPlugins || !userPlugins.some((p) => p === "importAssertions" || p === "importAttributes" || isArray$3(p) && p[0] === "importAttributes")) plugins.push("importAttributes");
	if (lang === "jsx" || lang === "tsx" || lang === "mtsx") plugins.push("jsx");
	else if (userPlugins) userPlugins = userPlugins.filter((p) => p !== "jsx");
	if (lang === "ts" || lang === "mts" || lang === "tsx" || lang === "cts" || lang === "mtsx") {
		plugins.push(["typescript", { dts }], "explicitResourceManagement");
		if (!userPlugins || !userPlugins.includes("decorators")) plugins.push("decorators-legacy");
	}
	if (userPlugins) plugins.push(...userPlugins);
	return plugins;
}
//#endregion
//#region packages/compiler-sfc/src/rewriteDefault.ts
function rewriteDefault(input, as, parserPlugins) {
	const ast = (0, import_lib.parse)(input, {
		sourceType: "module",
		plugins: resolveParserPlugins("js", parserPlugins)
	}).program.body;
	const s = new MagicString(input);
	rewriteDefaultAST(ast, s, as);
	return s.toString();
}
/**
* Utility for rewriting `export default` in a script block into a variable
* declaration so that we can inject things into it
*/
function rewriteDefaultAST(ast, s, as) {
	if (!hasDefaultExport(ast)) {
		s.append(`\nconst ${as} = {}`);
		return;
	}
	ast.forEach((node) => {
		if (node.type === "ExportDefaultDeclaration") {
			if (node.declaration.type === "ClassDeclaration" && node.declaration.id) {
				const start = node.declaration.decorators && node.declaration.decorators.length > 0 ? node.declaration.decorators[node.declaration.decorators.length - 1].end : node.start;
				s.overwrite(start, node.declaration.id.start, ` class `);
				s.append(`\nconst ${as} = ${node.declaration.id.name}`);
			} else s.overwrite(node.start, node.declaration.start, `const ${as} = `);
		} else if (node.type === "ExportNamedDeclaration") {
			for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier" && specifier.exported.type === "Identifier" && specifier.exported.name === "default") {
				if (node.source) {
					if (specifier.local.name === "default") {
						s.prepend(`import { default as __VUE_DEFAULT__ } from '${node.source.value}'\n`);
						const end = specifierEnd(s, specifier.local.end, node.end);
						s.remove(specifier.start, end);
						s.append(`\nconst ${as} = __VUE_DEFAULT__`);
						continue;
					} else {
						s.prepend(`import { ${s.slice(specifier.local.start, specifier.local.end)} as __VUE_DEFAULT__ } from '${node.source.value}'\n`);
						const end = specifierEnd(s, specifier.exported.end, node.end);
						s.remove(specifier.start, end);
						s.append(`\nconst ${as} = __VUE_DEFAULT__`);
						continue;
					}
				}
				const end = specifierEnd(s, specifier.end, node.end);
				s.remove(specifier.start, end);
				s.append(`\nconst ${as} = ${specifier.local.name}`);
			}
		}
	});
}
function hasDefaultExport(ast) {
	for (const stmt of ast) if (stmt.type === "ExportDefaultDeclaration") return true;
	else if (stmt.type === "ExportNamedDeclaration" && stmt.specifiers.some((spec) => spec.exported.name === "default")) return true;
	return false;
}
function specifierEnd(s, end, nodeEnd) {
	let hasCommas = false;
	let oldEnd = end;
	while (end < nodeEnd) if (/\s/.test(s.slice(end, end + 1))) end++;
	else if (s.slice(end, end + 1) === ",") {
		end++;
		hasCommas = true;
		break;
	} else if (s.slice(end, end + 1) === "}") break;
	return hasCommas ? end : oldEnd;
}
//#endregion
//#region packages/compiler-sfc/src/script/normalScript.ts
init_objectSpread2();
const normalScriptDefaultVar = `__default__`;
function processNormalScript(ctx, scopeId) {
	const script = ctx.descriptor.script;
	try {
		let content = script.content;
		let map = script.map;
		const scriptAst = ctx.scriptAst;
		const bindings = analyzeScriptBindings(scriptAst.body);
		const { cssVars } = ctx.descriptor;
		const { genDefaultAs, isProd } = ctx.options;
		if (cssVars.length || genDefaultAs) {
			var _ctx$options$template;
			const defaultVar = genDefaultAs || normalScriptDefaultVar;
			const s = new MagicString(content);
			rewriteDefaultAST(scriptAst.body, s, defaultVar);
			content = s.toString();
			if (cssVars.length && !((_ctx$options$template = ctx.options.templateOptions) === null || _ctx$options$template === void 0 ? void 0 : _ctx$options$template.ssr)) content += genNormalScriptCssVarsCode(cssVars, bindings, scopeId, !!isProd, defaultVar);
			if (!genDefaultAs) content += `\nexport default ${defaultVar}`;
		}
		return _objectSpread2(_objectSpread2({}, script), {}, {
			content,
			map,
			bindings,
			scriptAst: scriptAst.body
		});
	} catch (e) {
		return script;
	}
}
//#endregion
//#region packages/compiler-sfc/src/script/resolveType.ts
init__polyfill_node_path();
init_objectSpread2();
var TypeScope = class {
	constructor(filename, source, offset = 0, imports = Object.create(null), types = Object.create(null), declares = Object.create(null)) {
		this.filename = filename;
		this.source = source;
		this.offset = offset;
		this.imports = imports;
		this.types = types;
		this.declares = declares;
		this.isGenericScope = false;
		this.resolvedImportSources = Object.create(null);
		this.exportedTypes = Object.create(null);
		this.exportedDeclares = Object.create(null);
	}
};
function recordScopeDep(ctx, scope) {
	if (scope && scope.filename !== ctx.filename) (ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(scope.filename);
}
function recordResolvedElementDeps(ctx, { props }) {
	for (const key in props) recordScopeDep(ctx, props[key]._ownerScope);
}
/**
* Resolve arbitrary type node to a list of type elements that can be then
* mapped to runtime props or emits.
*/
function resolveTypeElements(ctx, node, scope, typeParameters) {
	const canCache = !typeParameters;
	if (canCache && node._resolvedElements) {
		recordResolvedElementDeps(ctx, node._resolvedElements);
		return node._resolvedElements;
	}
	const resolved = innerResolveTypeElements(ctx, node, node._ownerScope || scope || ctxToScope(ctx), typeParameters);
	return canCache ? node._resolvedElements = resolved : resolved;
}
function innerResolveTypeElements(ctx, node, scope, typeParameters) {
	if (hasVueIgnore(node)) {
		if ((node.type === "TSIntersectionType" || node.type === "TSUnionType") && node.types.length > 1) return mergeElements([{ props: {} }, ...node.types.slice(1).map((t) => resolveTypeElements(ctx, t, scope, typeParameters))], node.type);
		return { props: {} };
	}
	switch (node.type) {
		case "TSTypeLiteral": return typeElementsToMap(ctx, node.members, scope, typeParameters);
		case "TSInterfaceDeclaration": return resolveInterfaceMembers(ctx, node, scope, typeParameters);
		case "TSTypeAliasDeclaration":
		case "TSTypeAnnotation":
		case "TSParenthesizedType": return resolveTypeElements(ctx, node.typeAnnotation, scope, typeParameters);
		case "TSFunctionType": return {
			props: {},
			calls: [node]
		};
		case "TSUnionType":
		case "TSIntersectionType": return mergeElements(node.types.map((t) => resolveTypeElements(ctx, t, scope, typeParameters)), node.type);
		case "TSMappedType": return resolveMappedType(ctx, node, scope, typeParameters);
		case "TSIndexedAccessType": return mergeElements(resolveIndexType(ctx, node, scope).map((t) => resolveTypeElements(ctx, t, t._ownerScope)), "TSUnionType");
		case "TSExpressionWithTypeArguments":
		case "TSTypeReference": {
			var _scope$imports$typeNa;
			const typeName = getReferenceName(node);
			if ((typeName === "ExtractPropTypes" || typeName === "ExtractPublicPropTypes") && node.typeParameters && ((_scope$imports$typeNa = scope.imports[typeName]) === null || _scope$imports$typeNa === void 0 ? void 0 : _scope$imports$typeNa.source) === "vue") return resolveExtractPropTypes(resolveTypeElements(ctx, node.typeParameters.params[0], scope, typeParameters), scope);
			const resolved = resolveTypeReference(ctx, node, scope);
			if (resolved) {
				let typeParams;
				if ((resolved.type === "TSTypeAliasDeclaration" || resolved.type === "TSInterfaceDeclaration") && resolved.typeParameters && node.typeParameters) {
					typeParams = Object.create(null);
					resolved.typeParameters.params.forEach((p, i) => {
						let param = typeParameters && typeParameters[p.name];
						if (!param) param = node.typeParameters.params[i];
						typeParams[p.name] = param;
					});
				}
				return resolveTypeElements(ctx, resolved, resolved._ownerScope, typeParams);
			} else {
				if (typeof typeName === "string") {
					if (typeParameters && typeParameters[typeName]) return resolveTypeElements(ctx, typeParameters[typeName], scope, typeParameters);
					if (SupportedBuiltinsSet.has(typeName)) return resolveBuiltin(ctx, node, typeName, scope, typeParameters);
					else if (typeName === "ReturnType" && node.typeParameters) {
						const ret = resolveReturnType(ctx, node.typeParameters.params[0], scope);
						if (ret) return resolveTypeElements(ctx, ret, scope);
					}
				}
				return ctx.error(`Unresolvable type reference or unsupported built-in utility type`, node, scope);
			}
		}
		case "TSImportType": {
			var _node$qualifier;
			if (getId(node.argument) === "vue" && ((_node$qualifier = node.qualifier) === null || _node$qualifier === void 0 ? void 0 : _node$qualifier.type) === "Identifier" && node.qualifier.name === "ExtractPropTypes" && node.typeParameters) return resolveExtractPropTypes(resolveTypeElements(ctx, node.typeParameters.params[0], scope), scope);
			const resolved = resolveTypeReference(ctx, node, importSourceToScope(ctx, node.argument, scope, node.argument.value));
			if (resolved) return resolveTypeElements(ctx, resolved, resolved._ownerScope);
			break;
		}
		case "TSTypeQuery": {
			const resolved = resolveTypeReference(ctx, node, scope);
			if (resolved) return resolveTypeElements(ctx, resolved, resolved._ownerScope);
		}
	}
	return ctx.error(`Unresolvable type: ${node.type}`, node, scope);
}
function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx), typeParameters) {
	const res = { props: {} };
	for (const e of elements) if (e.type === "TSPropertySignature" || e.type === "TSMethodSignature") {
		if (typeParameters) {
			scope = createChildScope(scope);
			scope.isGenericScope = true;
			Object.assign(scope.types, typeParameters);
		}
		e._ownerScope = scope;
		const name = getStringLiteralKey(e);
		if (name !== null) res.props[name] = e;
		else ctx.error(`Unsupported computed key in type referenced by a macro`, e.key, scope);
	} else if (e.type === "TSCallSignatureDeclaration") (res.calls || (res.calls = [])).push(e);
	return res;
}
function hasVueIgnore(node) {
	return !!(node.leadingComments && node.leadingComments.some((c) => c.value.includes("@vue-ignore")));
}
function mergeElements(maps, type) {
	if (maps.length === 1) return maps[0];
	const res = { props: {} };
	const { props: baseProps } = res;
	for (const { props, calls } of maps) {
		for (const key in props) if (!hasOwn(baseProps, key)) baseProps[key] = props[key];
		else baseProps[key] = createProperty(baseProps[key].key, {
			type,
			types: [baseProps[key], props[key]]
		}, baseProps[key]._ownerScope, baseProps[key].optional || props[key].optional);
		if (calls) (res.calls || (res.calls = [])).push(...calls);
	}
	return res;
}
function createProperty(key, typeAnnotation, scope, optional) {
	return {
		type: "TSPropertySignature",
		key,
		kind: "get",
		optional,
		typeAnnotation: {
			type: "TSTypeAnnotation",
			typeAnnotation
		},
		_ownerScope: scope
	};
}
function resolveInterfaceMembers(ctx, node, scope, typeParameters) {
	const base = typeElementsToMap(ctx, node.body.body, node._ownerScope, typeParameters);
	if (node.extends) for (const ext of node.extends) try {
		const { props, calls } = resolveTypeElements(ctx, ext, scope);
		for (const key in props) if (!hasOwn(base.props, key)) base.props[key] = props[key];
		if (calls) (base.calls || (base.calls = [])).push(...calls);
	} catch (e) {
		if (!ctx.silentOnExtendsFailure) ctx.error("Failed to resolve extends base type.\nIf this previously worked in 3.2, you can instruct the compiler to ignore this extend by adding /* @vue-ignore */ before it, for example:\n\ninterface Props extends /* @vue-ignore */ Base {}\n\nNote: both in 3.2 or with the ignore, the properties in the base type are treated as fallthrough attrs at runtime.", ext, scope);
	}
	return base;
}
function resolveMappedType(ctx, node, scope, typeParameters) {
	const res = { props: {} };
	let keys;
	if (node.nameType) {
		const { name, constraint } = node.typeParameter;
		scope = createChildScope(scope);
		Object.assign(scope.types, _objectSpread2(_objectSpread2({}, typeParameters), {}, { [name]: constraint }));
		keys = resolveStringType(ctx, node.nameType, scope);
	} else keys = resolveStringType(ctx, node.typeParameter.constraint, scope);
	for (const key of keys) res.props[key] = createProperty({
		type: "Identifier",
		name: key
	}, node.typeAnnotation, scope, !!node.optional);
	return res;
}
function resolveIndexType(ctx, node, scope) {
	if (node.indexType.type === "TSNumberKeyword") return resolveArrayElementType(ctx, node.objectType, scope);
	const { indexType, objectType } = node;
	const types = [];
	let keys;
	let resolved;
	if (indexType.type === "TSStringKeyword") {
		resolved = resolveTypeElements(ctx, objectType, scope);
		keys = Object.keys(resolved.props);
	} else {
		keys = resolveStringType(ctx, indexType, scope);
		resolved = resolveTypeElements(ctx, objectType, scope);
	}
	for (const key of keys) {
		var _resolved$props$key;
		const targetType = (_resolved$props$key = resolved.props[key]) === null || _resolved$props$key === void 0 || (_resolved$props$key = _resolved$props$key.typeAnnotation) === null || _resolved$props$key === void 0 ? void 0 : _resolved$props$key.typeAnnotation;
		if (targetType) {
			targetType._ownerScope = resolved.props[key]._ownerScope;
			types.push(targetType);
		}
	}
	return types;
}
function resolveArrayElementType(ctx, node, scope) {
	if (node.type === "TSArrayType") return [node.elementType];
	if (node.type === "TSTupleType") return node.elementTypes.map((t) => t.type === "TSNamedTupleMember" ? t.elementType : t);
	if (node.type === "TSTypeReference") {
		if (getReferenceName(node) === "Array" && node.typeParameters) return node.typeParameters.params;
		else {
			const resolved = resolveTypeReference(ctx, node, scope);
			if (resolved) return resolveArrayElementType(ctx, resolved, scope);
		}
	}
	return ctx.error("Failed to resolve element type from target type", node, scope);
}
function resolveStringType(ctx, node, scope, typeParameters) {
	switch (node.type) {
		case "StringLiteral": return [node.value];
		case "TSLiteralType": return resolveStringType(ctx, node.literal, scope, typeParameters);
		case "TSUnionType": return node.types.map((t) => resolveStringType(ctx, t, scope, typeParameters)).flat();
		case "TemplateLiteral": return resolveTemplateKeys(ctx, node, scope);
		case "TSTypeReference": {
			const resolved = resolveTypeReference(ctx, node, scope);
			if (resolved) return resolveStringType(ctx, resolved, scope, typeParameters);
			if (node.typeName.type === "Identifier") {
				const name = node.typeName.name;
				if (typeParameters && typeParameters[name]) return resolveStringType(ctx, typeParameters[name], scope, typeParameters);
				const getParam = (index = 0) => resolveStringType(ctx, node.typeParameters.params[index], scope, typeParameters);
				switch (name) {
					case "Extract": return getParam(1);
					case "Exclude": {
						const excluded = getParam(1);
						return getParam().filter((s) => !excluded.includes(s));
					}
					case "Uppercase": return getParam().map((s) => s.toUpperCase());
					case "Lowercase": return getParam().map((s) => s.toLowerCase());
					case "Capitalize": return getParam().map(capitalize);
					case "Uncapitalize": return getParam().map((s) => s[0].toLowerCase() + s.slice(1));
					default: ctx.error("Unsupported type when resolving index type", node.typeName, scope);
				}
			}
		}
	}
	return ctx.error("Failed to resolve index type into finite keys", node, scope);
}
function resolveTemplateKeys(ctx, node, scope) {
	if (!node.expressions.length) return [node.quasis[0].value.raw];
	const res = [];
	const e = node.expressions[0];
	const q = node.quasis[0];
	const leading = q ? q.value.raw : ``;
	const resolved = resolveStringType(ctx, e, scope);
	const restResolved = resolveTemplateKeys(ctx, _objectSpread2(_objectSpread2({}, node), {}, {
		expressions: node.expressions.slice(1),
		quasis: q ? node.quasis.slice(1) : node.quasis
	}), scope);
	for (const r of resolved) for (const rr of restResolved) res.push(leading + r + rr);
	return res;
}
const SupportedBuiltinsSet = /* @__PURE__ */ new Set([
	"Partial",
	"Required",
	"Readonly",
	"Pick",
	"Omit"
]);
function resolveBuiltin(ctx, node, name, scope, typeParameters) {
	const t = resolveTypeElements(ctx, node.typeParameters.params[0], scope, typeParameters);
	switch (name) {
		case "Partial": {
			const res = {
				props: {},
				calls: t.calls
			};
			Object.keys(t.props).forEach((key) => {
				res.props[key] = _objectSpread2(_objectSpread2({}, t.props[key]), {}, { optional: true });
			});
			return res;
		}
		case "Required": {
			const res = {
				props: {},
				calls: t.calls
			};
			Object.keys(t.props).forEach((key) => {
				res.props[key] = _objectSpread2(_objectSpread2({}, t.props[key]), {}, { optional: false });
			});
			return res;
		}
		case "Readonly": return t;
		case "Pick": {
			const picked = resolveStringType(ctx, node.typeParameters.params[1], scope, typeParameters);
			const res = {
				props: {},
				calls: t.calls
			};
			for (const key of picked) res.props[key] = t.props[key];
			return res;
		}
		case "Omit":
			const omitted = resolveStringType(ctx, node.typeParameters.params[1], scope, typeParameters);
			const res = {
				props: {},
				calls: t.calls
			};
			for (const key in t.props) if (!omitted.includes(key)) res.props[key] = t.props[key];
			return res;
	}
}
function resolveTypeReference(ctx, node, scope, name, onlyExported = false) {
	const canCache = !(scope === null || scope === void 0 ? void 0 : scope.isGenericScope);
	if (canCache && node._resolvedReference) {
		recordScopeDep(ctx, node._resolvedReference._ownerScope);
		return node._resolvedReference;
	}
	const resolved = innerResolveTypeReference(ctx, scope || ctxToScope(ctx), name || getReferenceName(node), node, onlyExported);
	if (canCache) Object.defineProperty(node, "_resolvedReference", {
		value: resolved,
		writable: true,
		configurable: true,
		enumerable: false
	});
	return resolved;
}
function innerResolveTypeReference(ctx, scope, name, node, onlyExported) {
	if (typeof name === "string") {
		if (scope.imports[name]) return resolveTypeFromImport(ctx, node, name, scope);
		else {
			const lookupSource = node.type === "TSTypeQuery" ? onlyExported ? scope.exportedDeclares : scope.declares : onlyExported ? scope.exportedTypes : scope.types;
			if (lookupSource[name]) return lookupSource[name];
			else {
				const globalScopes = resolveGlobalScope(ctx);
				if (globalScopes) for (const s of globalScopes) {
					const src = node.type === "TSTypeQuery" ? s.declares : s.types;
					if (src[name]) {
						(ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(s.filename);
						const resolved = src[name];
						if (resolved._ownerScope && resolved._ownerScope !== s) ctx.deps.add(resolved._ownerScope.filename);
						return resolved;
					}
				}
			}
		}
	} else {
		let ns = innerResolveTypeReference(ctx, scope, name[0], node, onlyExported);
		if (ns) {
			if (ns.type !== "TSModuleDeclaration") ns = ns._ns;
			if (ns) return innerResolveTypeReference(ctx, moduleDeclToScope(ctx, ns, ns._ownerScope || scope), name.length > 2 ? name.slice(1) : name[name.length - 1], node, !ns.declare);
		}
	}
}
function getReferenceName(node) {
	const ref = node.type === "TSTypeReference" ? node.typeName : node.type === "TSExpressionWithTypeArguments" ? node.expression : node.type === "TSImportType" ? node.qualifier : node.exprName;
	if ((ref === null || ref === void 0 ? void 0 : ref.type) === "Identifier") return ref.name;
	else if ((ref === null || ref === void 0 ? void 0 : ref.type) === "TSQualifiedName") return qualifiedNameToPath(ref);
	else return "default";
}
function qualifiedNameToPath(node) {
	if (node.type === "Identifier") return [node.name];
	else return [...qualifiedNameToPath(node.left), node.right.name];
}
function resolveGlobalScope(ctx) {
	if (ctx.options.globalTypeFiles) {
		if (!resolveFS(ctx)) throw new Error("[vue/compiler-sfc] globalTypeFiles requires fs access.");
		return ctx.options.globalTypeFiles.map((file) => fileToScope(ctx, normalizePath(file), true));
	}
}
let ts;
let loadTS;
/**
* @private
*/
function registerTS(_loadTS) {
	loadTS = () => {
		try {
			return _loadTS();
		} catch (err) {
			if (typeof err.message === "string" && err.message.includes("Cannot find module")) throw new Error("Failed to load TypeScript, which is required for resolving imported types. Please make sure \"TypeScript\" is installed as a project dependency.");
			else throw new Error("Failed to load TypeScript for resolving imported types.");
		}
	};
}
function resolveFS(ctx) {
	if (ctx.fs) return ctx.fs;
	if (!ts && loadTS) ts = loadTS();
	const fs = ctx.options.fs || (ts === null || ts === void 0 ? void 0 : ts.sys);
	if (!fs) return;
	return ctx.fs = {
		fileExists(file) {
			if (file.endsWith(".vue.ts") && !file.endsWith(".d.vue.ts")) file = file.replace(/\.ts$/, "");
			return fs.fileExists(file);
		},
		readFile(file) {
			if (file.endsWith(".vue.ts") && !file.endsWith(".d.vue.ts")) file = file.replace(/\.ts$/, "");
			return fs.readFile(file);
		},
		realpath: fs.realpath
	};
}
function resolveTypeFromImport(ctx, node, name, scope) {
	const { source, imported } = scope.imports[name];
	return resolveTypeReference(ctx, node, importSourceToScope(ctx, node, scope, source), imported, true);
}
function importSourceToScope(ctx, node, scope, source, trackDep = true) {
	let fs;
	try {
		fs = resolveFS(ctx);
	} catch (err) {
		return ctx.error(err.message, node, scope);
	}
	if (!fs) return ctx.error("No fs option provided to `compileScript` in non-Node environment. File system access is required for resolving imported types.", node, scope);
	let resolved = scope.resolvedImportSources[source];
	if (!resolved) {
		if (source.startsWith("..")) resolved = resolveExt(joinPaths(dirname(scope.filename), source), fs);
		else if (source[0] === ".") resolved = resolveExt(joinPaths(dirname(scope.filename), source), fs);
		else return ctx.error(`Type import from non-relative sources is not supported in the browser build.`, node, scope);
		if (!resolved && source[0] === "." && false);
		if (resolved) resolved = scope.resolvedImportSources[source] = normalizePath(resolved);
	}
	if (resolved) {
		if (trackDep) (ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(resolved);
		return fileToScope(ctx, resolved);
	} else return ctx.error(`Failed to resolve import source ${JSON.stringify(source)}.`, node, scope);
}
function resolveExt(filename, fs) {
	let moduleType = "u";
	if (filename.endsWith(".mjs")) moduleType = "m";
	else if (filename.endsWith(".cjs")) moduleType = "c";
	filename = filename.replace(/\.[cm]?jsx?$/, "");
	const tryResolve = (filename) => {
		if (fs.fileExists(filename)) return filename;
	};
	const resolveTs = () => tryResolve(filename + `.ts`) || tryResolve(filename + `.tsx`) || tryResolve(filename + `.d.ts`);
	const resolveMts = () => tryResolve(filename + `.mts`) || tryResolve(filename + `.d.mts`);
	const resolveCts = () => tryResolve(filename + `.cts`) || tryResolve(filename + `.d.cts`);
	return tryResolve(filename) || (moduleType === "m" ? resolveMts() || resolveTs() : moduleType === "c" ? resolveCts() || resolveTs() : resolveTs() || resolveMts() || resolveCts()) || tryResolve(joinPaths(filename, `index.ts`)) || tryResolve(joinPaths(filename, `index.tsx`)) || tryResolve(joinPaths(filename, `index.d.ts`));
}
const tsConfigCache = createCache();
const tsConfigRefMap = /* @__PURE__ */ new Map();
const extendedConfigCache = /* @__PURE__ */ new Map();
const fileToScopeCache = createCache();
const fileToGlobalScopeCache = createCache();
/**
* @private
*/
function invalidateTypeCache(filename) {
	filename = normalizePath(filename);
	fileToScopeCache.delete(filename);
	fileToGlobalScopeCache.delete(filename);
	tsConfigCache.delete(filename);
	if (filename.endsWith(".json")) {
		extendedConfigCache.clear();
		tsConfigCache.clear();
	}
	const affectedConfig = tsConfigRefMap.get(filename);
	if (affectedConfig) tsConfigCache.delete(affectedConfig);
}
function fileToScope(ctx, filename, asGlobal = false) {
	const cache = asGlobal ? fileToGlobalScopeCache : fileToScopeCache;
	const cached = cache.get(filename);
	if (cached) return cached;
	const fs = resolveFS(ctx);
	const source = fs.readFile(filename) || "";
	const body = parseFile(filename, source, fs, ctx.options.babelParserPlugins);
	const scope = new TypeScope(filename, source, 0, recordImports(body));
	recordTypes(ctx, body, scope, asGlobal);
	cache.set(filename, scope);
	return scope;
}
function parseFile(filename, content, fs, parserPlugins) {
	const ext = extname(filename);
	if (ext === ".ts" || ext === ".mts" || ext === ".tsx" || ext === ".cts" || ext === ".mtsx") return (0, import_lib.parse)(content, {
		plugins: resolveParserPlugins(ext.slice(1), parserPlugins, /\.d\.[cm]?ts$/.test(filename)),
		sourceType: "module"
	}).program.body;
	const isUnknownTypeSource = !/\.[cm]?[tj]sx?$/.test(filename);
	const arbitraryTypeSource = `${filename.slice(0, -ext.length)}.d${ext}.ts`;
	if (isUnknownTypeSource && fs.fileExists(arbitraryTypeSource)) return (0, import_lib.parse)(fs.readFile(arbitraryTypeSource), {
		plugins: resolveParserPlugins("ts", parserPlugins, true),
		sourceType: "module"
	}).program.body;
	if (ext === ".vue") {
		const { descriptor: { script, scriptSetup } } = parse(content);
		if (!script && !scriptSetup) return [];
		const scriptOffset = script ? script.loc.start.offset : Infinity;
		const scriptSetupOffset = scriptSetup ? scriptSetup.loc.start.offset : Infinity;
		const firstBlock = scriptOffset < scriptSetupOffset ? script : scriptSetup;
		const secondBlock = scriptOffset < scriptSetupOffset ? scriptSetup : script;
		let scriptContent = " ".repeat(Math.min(scriptOffset, scriptSetupOffset)) + firstBlock.content;
		if (secondBlock) scriptContent += " ".repeat(secondBlock.loc.start.offset - script.loc.end.offset) + secondBlock.content;
		const lang = (script === null || script === void 0 ? void 0 : script.lang) || (scriptSetup === null || scriptSetup === void 0 ? void 0 : scriptSetup.lang);
		return (0, import_lib.parse)(scriptContent, {
			plugins: resolveParserPlugins(lang, parserPlugins),
			sourceType: "module"
		}).program.body;
	}
	return [];
}
function ctxToScope(ctx) {
	if (ctx.scope) return ctx.scope;
	const body = "ast" in ctx ? ctx.ast : ctx.scriptAst ? [...ctx.scriptAst.body, ...ctx.scriptSetupAst.body] : ctx.scriptSetupAst.body;
	const scope = new TypeScope(ctx.filename, ctx.source, "startOffset" in ctx ? ctx.startOffset : 0, "userImports" in ctx ? Object.create(ctx.userImports) : recordImports(body));
	recordTypes(ctx, body, scope);
	return ctx.scope = scope;
}
function moduleDeclToScope(ctx, node, parentScope) {
	if (node._resolvedChildScope) return node._resolvedChildScope;
	const scope = createChildScope(parentScope);
	if (node.body.type === "TSModuleDeclaration") {
		const decl = node.body;
		decl._ownerScope = scope;
		const id = getId(decl.id);
		scope.types[id] = scope.exportedTypes[id] = decl;
	} else recordTypes(ctx, node.body.body, scope);
	return node._resolvedChildScope = scope;
}
function createChildScope(parentScope) {
	return new TypeScope(parentScope.filename, parentScope.source, parentScope.offset, Object.create(parentScope.imports), Object.create(parentScope.types), Object.create(parentScope.declares));
}
const importExportRE = /^Import|^Export/;
function recordTypes(ctx, body, scope, asGlobal = false) {
	const { types, declares, exportedTypes, exportedDeclares, imports } = scope;
	const isAmbient = asGlobal ? !body.some((s) => importExportRE.test(s.type)) : false;
	for (const stmt of body) if (asGlobal) {
		if (isAmbient) {
			if (stmt.declare) recordType(stmt, types, declares);
		} else if (stmt.type === "TSModuleDeclaration" && stmt.global) for (const s of stmt.body.body) if (s.type === "ExportNamedDeclaration") {
			if (s.declaration) recordType(s.declaration, types, declares);
			else if (s.source) {
				const sourceScope = importSourceToScope(ctx, s.source, scope, s.source.value, false);
				for (const spec of s.specifiers) if (spec.type === "ExportSpecifier") {
					const exported = getId(spec.exported);
					const local = spec.local.name;
					if (sourceScope.exportedTypes[local]) types[exported] = sourceScope.exportedTypes[local];
					if (sourceScope.exportedDeclares[local]) declares[exported] = sourceScope.exportedDeclares[local];
				}
			}
		} else if (s.type === "ExportAllDeclaration" && s.source) {
			const sourceScope = importSourceToScope(ctx, s.source, scope, s.source.value, false);
			Object.assign(types, sourceScope.exportedTypes);
			Object.assign(declares, sourceScope.exportedDeclares);
		} else recordType(s, types, declares);
	} else recordType(stmt, types, declares);
	if (!asGlobal) {
		for (const stmt of body) if (stmt.type === "ExportNamedDeclaration") {
			if (stmt.declaration) {
				recordType(stmt.declaration, types, declares);
				recordType(stmt.declaration, exportedTypes, exportedDeclares);
			} else for (const spec of stmt.specifiers) if (spec.type === "ExportSpecifier") {
				const local = spec.local.name;
				const exported = getId(spec.exported);
				if (stmt.source) {
					imports[exported] = {
						source: stmt.source.value,
						imported: local
					};
					exportedTypes[exported] = {
						type: "TSTypeReference",
						typeName: {
							type: "Identifier",
							name: local
						},
						_ownerScope: scope
					};
				} else if (types[local]) exportedTypes[exported] = types[local];
			}
		} else if (stmt.type === "ExportAllDeclaration") {
			const sourceScope = importSourceToScope(ctx, stmt.source, scope, stmt.source.value);
			Object.assign(scope.exportedTypes, sourceScope.exportedTypes);
		} else if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
			if (stmt.declaration.type !== "Identifier") {
				recordType(stmt.declaration, types, declares, "default");
				recordType(stmt.declaration, exportedTypes, exportedDeclares, "default");
			} else if (types[stmt.declaration.name]) exportedTypes["default"] = types[stmt.declaration.name];
		}
	}
	for (const key of Object.keys(types)) {
		const node = types[key];
		if (!node._ownerScope) node._ownerScope = scope;
		if (node._ns && !node._ns._ownerScope) node._ns._ownerScope = scope;
	}
	for (const key of Object.keys(declares)) if (!declares[key]._ownerScope) declares[key]._ownerScope = scope;
}
function recordType(node, types, declares, overwriteId) {
	switch (node.type) {
		case "TSInterfaceDeclaration":
		case "TSEnumDeclaration":
		case "TSModuleDeclaration": {
			if (node.type === "TSModuleDeclaration" && node.global) {
				const body = node.body;
				for (const s of body.body) if (s.type === "ExportNamedDeclaration" && s.declaration) recordType(s.declaration, types, declares);
				else recordType(s, types, declares);
				break;
			}
			const id = overwriteId || getId(node.id);
			let existing = types[id];
			if (existing) {
				if (node.type === "TSModuleDeclaration") {
					if (existing.type === "TSModuleDeclaration") mergeNamespaces(existing, node);
					else attachNamespace(existing, node);
					break;
				}
				if (existing.type === "TSModuleDeclaration") {
					types[id] = node;
					attachNamespace(node, existing);
					break;
				}
				if (existing.type !== node.type) break;
				if (node.type === "TSInterfaceDeclaration") existing.body.body.push(...node.body.body);
				else existing.members.push(...node.members);
			} else types[id] = node;
			break;
		}
		case "ClassDeclaration":
			if (overwriteId || node.id) types[overwriteId || getId(node.id)] = node;
			break;
		case "TSTypeAliasDeclaration":
			types[node.id.name] = node.typeParameters ? node : node.typeAnnotation;
			break;
		case "TSDeclareFunction":
			if (node.id) declares[node.id.name] = node;
			break;
		case "VariableDeclaration": if (node.declare) {
			for (const decl of node.declarations) if (decl.id.type === "Identifier" && decl.id.typeAnnotation) declares[decl.id.name] = decl.id.typeAnnotation.typeAnnotation;
		}
	}
}
function mergeNamespaces(to, from) {
	const toBody = to.body;
	const fromBody = from.body;
	if (toBody.type === "TSModuleDeclaration") {
		if (fromBody.type === "TSModuleDeclaration") mergeNamespaces(toBody, fromBody);
		else fromBody.body.push({
			type: "ExportNamedDeclaration",
			declaration: toBody,
			exportKind: "type",
			specifiers: []
		});
	} else if (fromBody.type === "TSModuleDeclaration") toBody.body.push({
		type: "ExportNamedDeclaration",
		declaration: fromBody,
		exportKind: "type",
		specifiers: []
	});
	else toBody.body.push(...fromBody.body);
}
function attachNamespace(to, ns) {
	if (!to._ns) to._ns = ns;
	else mergeNamespaces(to._ns, ns);
}
function recordImports(body) {
	const imports = Object.create(null);
	for (const s of body) recordImport(s, imports);
	return imports;
}
function recordImport(node, imports) {
	if (node.type !== "ImportDeclaration") return;
	for (const s of node.specifiers) imports[s.local.name] = {
		imported: getImportedName(s),
		source: node.source.value
	};
}
function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx), isKeyOf = false, typeParameters) {
	if (node.leadingComments && node.leadingComments.some((c) => c.value.includes("@vue-ignore"))) return [UNKNOWN_TYPE];
	const prevSilent = ctx.silentOnExtendsFailure;
	ctx.silentOnExtendsFailure = true;
	try {
		switch (node.type) {
			case "TSStringKeyword": return ["String"];
			case "TSNumberKeyword": return ["Number"];
			case "TSBooleanKeyword": return ["Boolean"];
			case "TSObjectKeyword": return ["Object"];
			case "TSNullKeyword": return ["null"];
			case "TSTypeLiteral":
			case "TSInterfaceDeclaration": {
				const types = /* @__PURE__ */ new Set();
				const members = node.type === "TSTypeLiteral" ? node.members : node.body.body;
				for (const m of members) if (isKeyOf) {
					if (m.type === "TSPropertySignature" && m.key.type === "NumericLiteral") types.add("Number");
					else if (m.type === "TSIndexSignature") {
						const annotation = m.parameters[0].typeAnnotation;
						if (annotation && annotation.type !== "Noop") {
							const type = inferRuntimeType(ctx, annotation.typeAnnotation, scope)[0];
							if (type === "Unknown") return [UNKNOWN_TYPE];
							types.add(type);
						}
					} else types.add("String");
				} else if (m.type === "TSCallSignatureDeclaration" || m.type === "TSConstructSignatureDeclaration") types.add("Function");
				else types.add("Object");
				return types.size ? Array.from(types) : [isKeyOf ? UNKNOWN_TYPE : "Object"];
			}
			case "TSPropertySignature":
				if (node.typeAnnotation) return inferRuntimeType(ctx, node.typeAnnotation.typeAnnotation, scope);
				break;
			case "TSMethodSignature":
			case "TSFunctionType": return ["Function"];
			case "TSArrayType":
			case "TSTupleType": return ["Array"];
			case "TSLiteralType": switch (node.literal.type) {
				case "StringLiteral": return ["String"];
				case "BooleanLiteral": return ["Boolean"];
				case "NumericLiteral":
				case "BigIntLiteral": return ["Number"];
				default: return [UNKNOWN_TYPE];
			}
			case "TSTypeReference": {
				let resolved;
				try {
					resolved = resolveTypeReference(ctx, node, scope);
				} catch (_unused) {}
				if (resolved) {
					if (resolved.type === "TSTypeAliasDeclaration") {
						if (resolved.typeAnnotation.type === "TSFunctionType") return ["Function"];
						if (node.typeParameters) {
							const typeParams = Object.create(null);
							if (resolved.typeParameters) resolved.typeParameters.params.forEach((p, i) => {
								typeParams[p.name] = node.typeParameters.params[i];
							});
							return inferRuntimeType(ctx, resolved.typeAnnotation, resolved._ownerScope, isKeyOf, typeParams);
						}
					}
					return inferRuntimeType(ctx, resolved, resolved._ownerScope, isKeyOf);
				}
				if (node.typeName.type === "Identifier") {
					if (typeParameters && typeParameters[node.typeName.name]) return inferRuntimeType(ctx, typeParameters[node.typeName.name], scope, isKeyOf, typeParameters);
					if (isKeyOf) switch (node.typeName.name) {
						case "String":
						case "Array":
						case "ArrayLike":
						case "Parameters":
						case "ConstructorParameters":
						case "ReadonlyArray": return ["String", "Number"];
						case "Record":
						case "Partial":
						case "Required":
						case "Readonly":
							if (node.typeParameters && node.typeParameters.params[0]) return inferRuntimeType(ctx, node.typeParameters.params[0], scope, true);
							break;
						case "Pick":
						case "Extract":
							if (node.typeParameters && node.typeParameters.params[1]) return inferRuntimeType(ctx, node.typeParameters.params[1], scope);
							break;
						case "Function":
						case "Object":
						case "Set":
						case "Map":
						case "WeakSet":
						case "WeakMap":
						case "Date":
						case "Promise":
						case "Error":
						case "Uppercase":
						case "Lowercase":
						case "Capitalize":
						case "Uncapitalize":
						case "ReadonlyMap":
						case "ReadonlySet": return ["String"];
					}
					else switch (node.typeName.name) {
						case "Array":
						case "Function":
						case "Object":
						case "Set":
						case "Map":
						case "WeakSet":
						case "WeakMap":
						case "Date":
						case "Promise":
						case "Error": return [node.typeName.name];
						case "Partial":
						case "Required":
						case "Readonly":
						case "Record":
						case "Pick":
						case "Omit":
						case "InstanceType": return ["Object"];
						case "Uppercase":
						case "Lowercase":
						case "Capitalize":
						case "Uncapitalize": return ["String"];
						case "Parameters":
						case "ConstructorParameters":
						case "ReadonlyArray": return ["Array"];
						case "ReadonlyMap": return ["Map"];
						case "ReadonlySet": return ["Set"];
						case "Ref":
						case "ShallowRef":
						case "ComputedRef":
						case "WritableComputedRef": return ["Object"];
						case "MaybeRef":
						case "MaybeRefOrGetter": {
							const types = /* @__PURE__ */ new Set(["Object"]);
							if (node.typeName.name === "MaybeRefOrGetter") types.add("Function");
							if (node.typeParameters && node.typeParameters.params[0]) for (const t of inferRuntimeType(ctx, node.typeParameters.params[0], scope, false, typeParameters)) types.add(t);
							return Array.from(types);
						}
						case "NonNullable":
							if (node.typeParameters && node.typeParameters.params[0]) return inferRuntimeType(ctx, node.typeParameters.params[0], scope).filter((t) => t !== "null");
							break;
						case "Extract":
							if (node.typeParameters && node.typeParameters.params[1]) return inferRuntimeType(ctx, node.typeParameters.params[1], scope);
							break;
						case "Exclude":
						case "OmitThisParameter": if (node.typeParameters && node.typeParameters.params[0]) return inferRuntimeType(ctx, node.typeParameters.params[0], scope);
					}
				}
				break;
			}
			case "TSParenthesizedType": return inferRuntimeType(ctx, node.typeAnnotation, scope);
			case "TSUnionType": return flattenTypes(ctx, node.types, scope, isKeyOf, typeParameters);
			case "TSIntersectionType": return flattenTypes(ctx, node.types, scope, isKeyOf, typeParameters).filter((t) => t !== UNKNOWN_TYPE);
			case "TSMappedType": {
				const { typeAnnotation, typeParameter } = node;
				if (typeAnnotation && typeAnnotation.type === "TSIndexedAccessType" && typeParameter && typeParameter.constraint && typeParameters) {
					const constraint = typeParameter.constraint;
					if (constraint.type === "TSTypeOperator" && constraint.operator === "keyof" && constraint.typeAnnotation && constraint.typeAnnotation.type === "TSTypeReference" && constraint.typeAnnotation.typeName.type === "Identifier") {
						const typeName = constraint.typeAnnotation.typeName.name;
						const index = typeAnnotation.indexType;
						const obj = typeAnnotation.objectType;
						if (obj && obj.type === "TSTypeReference" && obj.typeName.type === "Identifier" && obj.typeName.name === typeName && index && index.type === "TSTypeReference" && index.typeName.type === "Identifier" && index.typeName.name === typeParameter.name) {
							const targetType = typeParameters[typeName];
							if (targetType) return inferRuntimeType(ctx, targetType, scope);
						}
					}
				}
				return [UNKNOWN_TYPE];
			}
			case "TSEnumDeclaration": return inferEnumType(node);
			case "TSSymbolKeyword": return ["Symbol"];
			case "TSIndexedAccessType": return flattenTypes(ctx, resolveIndexType(ctx, node, scope), scope, isKeyOf);
			case "ClassDeclaration": return ["Object"];
			case "TSImportType": {
				const resolved = resolveTypeReference(ctx, node, importSourceToScope(ctx, node.argument, scope, node.argument.value));
				if (resolved) return inferRuntimeType(ctx, resolved, resolved._ownerScope);
				break;
			}
			case "TSTypeQuery": {
				const id = node.exprName;
				if (id.type === "Identifier") {
					const matched = scope.declares[id.name];
					if (matched) return inferRuntimeType(ctx, matched, matched._ownerScope, isKeyOf);
				}
				break;
			}
			case "TSTypeOperator": return inferRuntimeType(ctx, node.typeAnnotation, scope, node.operator === "keyof");
			case "TSAnyKeyword": if (isKeyOf) return [
				"String",
				"Number",
				"Symbol"
			];
		}
	} catch (e) {} finally {
		ctx.silentOnExtendsFailure = prevSilent;
	}
	return [UNKNOWN_TYPE];
}
function flattenTypes(ctx, types, scope, isKeyOf = false, typeParameters = void 0) {
	if (types.length === 1) return inferRuntimeType(ctx, types[0], types[0]._ownerScope || scope, isKeyOf, typeParameters);
	return [...new Set([].concat(...types.map((t) => inferRuntimeType(ctx, t, t._ownerScope || scope, isKeyOf, typeParameters))))];
}
function inferEnumType(node) {
	const types = /* @__PURE__ */ new Set();
	for (const m of node.members) if (m.initializer) switch (m.initializer.type) {
		case "StringLiteral":
			types.add("String");
			break;
		case "NumericLiteral": types.add("Number");
	}
	return types.size ? [...types] : ["Number"];
}
/**
* support for the `ExtractPropTypes` helper - it's non-exhaustive, mostly
* tailored towards popular component libs like element-plus and antd-vue.
*/
function resolveExtractPropTypes({ props }, scope) {
	const res = { props: {} };
	for (const key in props) {
		const raw = props[key];
		res.props[key] = reverseInferType(raw.key, raw.typeAnnotation.typeAnnotation, scope);
	}
	return res;
}
function reverseInferType(key, node, scope, optional = true, checkObjectSyntax = true) {
	if (checkObjectSyntax && node.type === "TSTypeLiteral") {
		const typeType = findStaticPropertyType(node, "type");
		if (typeType) {
			const requiredType = findStaticPropertyType(node, "required");
			return reverseInferType(key, typeType, scope, requiredType && requiredType.type === "TSLiteralType" && requiredType.literal.type === "BooleanLiteral" ? !requiredType.literal.value : true, false);
		}
	} else if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
		if (node.typeName.name.endsWith("Constructor")) return createProperty(key, ctorToType(node.typeName.name), scope, optional);
		else if (node.typeName.name === "PropType" && node.typeParameters) return createProperty(key, node.typeParameters.params[0], scope, optional);
	}
	if ((node.type === "TSTypeReference" || node.type === "TSImportType") && node.typeParameters) for (const t of node.typeParameters.params) {
		const inferred = reverseInferType(key, t, scope, optional);
		if (inferred) return inferred;
	}
	return createProperty(key, { type: `TSNullKeyword` }, scope, optional);
}
function ctorToType(ctorType) {
	const ctor = ctorType.slice(0, -11);
	switch (ctor) {
		case "String":
		case "Number":
		case "Boolean": return { type: `TS${ctor}Keyword` };
		case "Array":
		case "Function":
		case "Object":
		case "Set":
		case "Map":
		case "WeakSet":
		case "WeakMap":
		case "Date":
		case "Promise": return {
			type: "TSTypeReference",
			typeName: {
				type: "Identifier",
				name: ctor
			}
		};
	}
	return { type: `TSNullKeyword` };
}
function findStaticPropertyType(node, key) {
	const prop = node.members.find((m) => m.type === "TSPropertySignature" && getStringLiteralKey(m) === key && m.typeAnnotation);
	return prop && prop.typeAnnotation.typeAnnotation;
}
function resolveReturnType(ctx, arg, scope) {
	let resolved = arg;
	if (arg.type === "TSTypeReference" || arg.type === "TSTypeQuery" || arg.type === "TSImportType") resolved = resolveTypeReference(ctx, arg, scope);
	if (!resolved) return;
	if (resolved.type === "TSFunctionType") {
		var _resolved$typeAnnotat;
		return (_resolved$typeAnnotat = resolved.typeAnnotation) === null || _resolved$typeAnnotat === void 0 ? void 0 : _resolved$typeAnnotat.typeAnnotation;
	}
	if (resolved.type === "TSDeclareFunction") return resolved.returnType;
}
function resolveUnionType(ctx, node, scope) {
	if (node.type === "TSTypeReference") {
		const resolved = resolveTypeReference(ctx, node, scope);
		if (resolved) node = resolved;
	}
	let types;
	if (node.type === "TSUnionType") types = node.types.flatMap((node) => resolveUnionType(ctx, node, scope));
	else types = [node];
	return types;
}
//#endregion
//#region packages/compiler-sfc/src/script/defineModel.ts
const DEFINE_MODEL = "defineModel";
function processDefineModel(ctx, node, declId) {
	if (!isCallOf(node, "defineModel")) return false;
	ctx.hasDefineModelCall = true;
	const type = node.typeParameters && node.typeParameters.params[0] || void 0;
	let modelName;
	let options;
	const arg0 = node.arguments[0] && unwrapTSNode(node.arguments[0]);
	const hasName = arg0 && (arg0.type === "StringLiteral" || arg0.type === "TemplateLiteral" && arg0.expressions.length === 0);
	if (hasName) {
		modelName = arg0.type === "StringLiteral" ? arg0.value : arg0.quasis[0].value.cooked;
		options = node.arguments[1];
	} else {
		modelName = "modelValue";
		options = arg0;
	}
	if (ctx.modelDecls[modelName]) ctx.error(`duplicate model name ${JSON.stringify(modelName)}`, node);
	let optionsString = options && ctx.getString(options);
	let optionsRemoved = !options;
	const runtimeOptionNodes = [];
	if (options && options.type === "ObjectExpression" && !options.properties.some((p) => p.type === "SpreadElement" || p.computed)) {
		let removed = 0;
		for (let i = options.properties.length - 1; i >= 0; i--) {
			const p = options.properties[i];
			const next = options.properties[i + 1];
			const start = p.start;
			const end = next ? next.start : options.end - 1;
			if ((p.type === "ObjectProperty" || p.type === "ObjectMethod") && (p.key.type === "Identifier" && (p.key.name === "get" || p.key.name === "set") || p.key.type === "StringLiteral" && (p.key.value === "get" || p.key.value === "set"))) optionsString = optionsString.slice(0, start - options.start) + optionsString.slice(end - options.start);
			else {
				removed++;
				ctx.s.remove(ctx.startOffset + start, ctx.startOffset + end);
				runtimeOptionNodes.push(p);
			}
		}
		if (removed === options.properties.length) {
			optionsRemoved = true;
			ctx.s.remove(ctx.startOffset + (hasName ? arg0.end : options.start), ctx.startOffset + options.end);
		}
	}
	ctx.modelDecls[modelName] = {
		type,
		options: optionsString,
		runtimeOptionNodes,
		identifier: declId && declId.type === "Identifier" ? declId.name : void 0
	};
	ctx.bindingMetadata[modelName] = "props";
	ctx.s.overwrite(ctx.startOffset + node.callee.start, ctx.startOffset + node.callee.end, ctx.helper("useModel"));
	ctx.s.appendLeft(ctx.startOffset + (node.arguments.length ? node.arguments[0].start : node.end - 1), `__props, ` + (hasName ? `` : `${JSON.stringify(modelName)}${optionsRemoved ? `` : `, `}`));
	return true;
}
function genModelProps(ctx) {
	if (!ctx.hasDefineModelCall) return;
	const isProd = !!ctx.options.isProd;
	let modelPropsDecl = "";
	for (const [name, { type, options: runtimeOptions }] of Object.entries(ctx.modelDecls)) {
		let skipCheck = false;
		let codegenOptions = ``;
		let runtimeTypes = type && inferRuntimeType(ctx, type);
		if (runtimeTypes) {
			const hasBoolean = runtimeTypes.includes("Boolean");
			const hasFunction = runtimeTypes.includes("Function");
			if (runtimeTypes.includes("Unknown")) {
				if (hasBoolean || hasFunction) {
					runtimeTypes = runtimeTypes.filter((t) => t !== UNKNOWN_TYPE);
					skipCheck = true;
				} else runtimeTypes = ["null"];
			}
			if (!isProd) codegenOptions = `type: ${toRuntimeTypeString(runtimeTypes)}` + (skipCheck ? ", skipCheck: true" : "");
			else if (hasBoolean || runtimeOptions && hasFunction) codegenOptions = `type: ${toRuntimeTypeString(runtimeTypes)}`;
		}
		let decl;
		if (codegenOptions && runtimeOptions) decl = ctx.isTS ? `{ ${codegenOptions}, ...${runtimeOptions} }` : `Object.assign({ ${codegenOptions} }, ${runtimeOptions})`;
		else if (codegenOptions) decl = `{ ${codegenOptions} }`;
		else if (runtimeOptions) decl = runtimeOptions;
		else decl = `{}`;
		modelPropsDecl += `\n    ${JSON.stringify(name)}: ${decl},`;
		const modifierPropName = JSON.stringify(getModifierPropName(name));
		modelPropsDecl += `\n    ${modifierPropName}: {},`;
	}
	return `{${modelPropsDecl}\n  }`;
}
//#endregion
//#region packages/compiler-sfc/src/script/defineProps.ts
const DEFINE_PROPS = "defineProps";
const WITH_DEFAULTS = "withDefaults";
function processDefineProps(ctx, node, declId, isWithDefaults = false) {
	if (!isCallOf(node, "defineProps")) return processWithDefaults(ctx, node, declId);
	if (ctx.hasDefinePropsCall) ctx.error(`duplicate ${DEFINE_PROPS}() call`, node);
	ctx.hasDefinePropsCall = true;
	ctx.propsRuntimeDecl = node.arguments[0];
	if (ctx.propsRuntimeDecl) {
		for (const key of getObjectOrArrayExpressionKeys(ctx.propsRuntimeDecl)) if (!(key in ctx.bindingMetadata)) ctx.bindingMetadata[key] = "props";
	}
	if (node.typeParameters) {
		if (ctx.propsRuntimeDecl) ctx.error(`${DEFINE_PROPS}() cannot accept both type and non-type arguments at the same time. Use one or the other.`, node);
		ctx.propsTypeDecl = node.typeParameters.params[0];
		const { props } = resolveTypeElements(ctx, ctx.propsTypeDecl);
		if (props) {
			for (const key in props) if (!(key in ctx.bindingMetadata)) ctx.bindingMetadata[key] = "props";
		}
	}
	if (!isWithDefaults && declId && declId.type === "ObjectPattern") processPropsDestructure(ctx, declId);
	ctx.propsCall = node;
	ctx.propsDecl = declId;
	return true;
}
function processWithDefaults(ctx, node, declId) {
	if (!isCallOf(node, "withDefaults")) return false;
	if (!processDefineProps(ctx, node.arguments[0], declId, true)) ctx.error(`${WITH_DEFAULTS}' first argument must be a ${DEFINE_PROPS} call.`, node.arguments[0] || node);
	if (ctx.propsRuntimeDecl) ctx.error(`${WITH_DEFAULTS} can only be used with type-based ${DEFINE_PROPS} declaration.`, node);
	if (declId && declId.type === "ObjectPattern") ctx.warn(`${WITH_DEFAULTS}() is unnecessary when using destructure with ${DEFINE_PROPS}().\nReactive destructure will be disabled when using withDefaults().\nPrefer using destructure default values, e.g. const { foo = 1 } = defineProps(...). `, node.callee);
	ctx.propsRuntimeDefaults = node.arguments[1];
	if (!ctx.propsRuntimeDefaults) ctx.error(`The 2nd argument of ${WITH_DEFAULTS} is required.`, node);
	ctx.propsCall = node;
	return true;
}
function genRuntimeProps(ctx) {
	let propsDecls;
	if (ctx.propsRuntimeDecl) {
		propsDecls = ctx.getString(ctx.propsRuntimeDecl).trim();
		if (ctx.propsDestructureDecl) {
			const defaults = [];
			for (const key in ctx.propsDestructuredBindings) {
				const d = genDestructuredDefaultValue(ctx, key);
				const finalKey = getEscapedPropName(key);
				if (d) defaults.push(`${finalKey}: ${d.valueString}${d.needSkipFactory ? `, __skip_${finalKey}: true` : ``}`);
			}
			if (defaults.length) propsDecls = `/*@__PURE__*/${ctx.helper(`mergeDefaults`)}(${propsDecls}, {\n  ${defaults.join(",\n  ")}\n})`;
		}
	} else if (ctx.propsTypeDecl) propsDecls = extractRuntimeProps(ctx);
	const modelsDecls = genModelProps(ctx);
	if (propsDecls && modelsDecls) return `/*@__PURE__*/${ctx.helper("mergeModels")}(${propsDecls}, ${modelsDecls})`;
	else return modelsDecls || propsDecls;
}
function extractRuntimeProps(ctx) {
	const props = resolveRuntimePropsFromType(ctx, ctx.propsTypeDecl);
	if (!props.length) return;
	const propStrings = [];
	const hasStaticDefaults = hasStaticWithDefaults(ctx);
	for (const prop of props) propStrings.push(genRuntimePropFromType(ctx, prop, hasStaticDefaults));
	let propsDecls = `{
    ${propStrings.join(",\n    ")}\n  }`;
	if (ctx.propsRuntimeDefaults && !hasStaticDefaults) propsDecls = `/*@__PURE__*/${ctx.helper("mergeDefaults")}(${propsDecls}, ${ctx.getString(ctx.propsRuntimeDefaults)})`;
	return propsDecls;
}
function resolveRuntimePropsFromType(ctx, node) {
	const props = [];
	const elements = resolveTypeElements(ctx, node);
	for (const key in elements.props) {
		const e = elements.props[key];
		let type = inferRuntimeType(ctx, e);
		let skipCheck = false;
		if (type.includes("Unknown")) {
			if (type.includes("Boolean") || type.includes("Function")) {
				type = type.filter((t) => t !== UNKNOWN_TYPE);
				skipCheck = true;
			} else type = ["null"];
		}
		props.push({
			key,
			required: !e.optional,
			type: type || [`null`],
			skipCheck
		});
	}
	return props;
}
function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStaticDefaults) {
	let defaultString;
	const destructured = genDestructuredDefaultValue(ctx, key, type);
	if (destructured) defaultString = `default: ${destructured.valueString}${destructured.needSkipFactory ? `, skipFactory: true` : ``}`;
	else if (hasStaticDefaults) {
		const prop = ctx.propsRuntimeDefaults.properties.find((node) => {
			if (node.type === "SpreadElement") return false;
			return resolveObjectKey(node.key, node.computed) === key;
		});
		if (prop) {
			if (prop.type === "ObjectProperty") defaultString = `default: ${ctx.getString(prop.value)}`;
			else {
				let paramsString = "";
				if (prop.params.length) {
					const start = prop.params[0].start;
					const end = prop.params[prop.params.length - 1].end;
					paramsString = ctx.getString({
						start,
						end
					});
				}
				defaultString = `${prop.async ? "async " : ""}${prop.kind !== "method" ? `${prop.kind} ` : ""}default(${paramsString}) ${ctx.getString(prop.body)}`;
			}
		}
	}
	const finalKey = getEscapedPropName(key);
	if (!ctx.options.isProd) return `${finalKey}: { ${concatStrings([
		`type: ${toRuntimeTypeString(type)}`,
		`required: ${required}`,
		skipCheck && "skipCheck: true",
		defaultString
	])} }`;
	else if (type.some((el) => el === "Boolean" || (!hasStaticDefaults || defaultString) && el === "Function")) return `${finalKey}: { ${concatStrings([`type: ${toRuntimeTypeString(type)}`, defaultString])} }`;
	else {
		if (ctx.isCE) {
			if (defaultString) return `${finalKey}: ${`{ ${defaultString}, type: ${toRuntimeTypeString(type)} }`}`;
			else return `${finalKey}: {type: ${toRuntimeTypeString(type)}}`;
		}
		return `${finalKey}: ${defaultString ? `{ ${defaultString} }` : `{}`}`;
	}
}
/**
* check defaults. If the default object is an object literal with only
* static properties, we can directly generate more optimized default
* declarations. Otherwise we will have to fallback to runtime merging.
*/
function hasStaticWithDefaults(ctx) {
	return !!(ctx.propsRuntimeDefaults && ctx.propsRuntimeDefaults.type === "ObjectExpression" && ctx.propsRuntimeDefaults.properties.every((node) => node.type !== "SpreadElement" && (!node.computed || node.key.type.endsWith("Literal"))));
}
function genDestructuredDefaultValue(ctx, key, inferredType) {
	const destructured = ctx.propsDestructuredBindings[key];
	const defaultVal = destructured && destructured.default;
	if (defaultVal) {
		const value = ctx.getString(defaultVal);
		const unwrapped = unwrapTSNode(defaultVal);
		if (inferredType && inferredType.length && !inferredType.includes("null")) {
			const valueType = inferValueType(unwrapped);
			if (valueType && !inferredType.includes(valueType)) ctx.error(`Default value of prop "${key}" does not match declared type.`, unwrapped);
		}
		const needSkipFactory = !inferredType && (isFunctionType(unwrapped) || unwrapped.type === "Identifier");
		return {
			valueString: !needSkipFactory && !isLiteralNode(unwrapped) && !(inferredType === null || inferredType === void 0 ? void 0 : inferredType.includes("Function")) ? `() => (${value})` : value,
			needSkipFactory
		};
	}
}
function inferValueType(node) {
	switch (node.type) {
		case "StringLiteral": return "String";
		case "NumericLiteral": return "Number";
		case "BooleanLiteral": return "Boolean";
		case "ObjectExpression": return "Object";
		case "ArrayExpression": return "Array";
		case "FunctionExpression":
		case "ArrowFunctionExpression": return "Function";
	}
}
//#endregion
//#region packages/compiler-sfc/src/script/definePropsDestructure.ts
function processPropsDestructure(ctx, declId) {
	if (ctx.options.propsDestructure === "error") ctx.error(`Props destructure is explicitly prohibited via config.`, declId);
	else if (ctx.options.propsDestructure === false) return;
	ctx.propsDestructureDecl = declId;
	const registerBinding = (key, local, defaultValue) => {
		ctx.propsDestructuredBindings[key] = {
			local,
			default: defaultValue
		};
		if (local !== key) {
			ctx.bindingMetadata[local] = "props-aliased";
			(ctx.bindingMetadata.__propsAliases || (ctx.bindingMetadata.__propsAliases = {}))[local] = key;
		}
	};
	for (const prop of declId.properties) if (prop.type === "ObjectProperty") {
		const propKey = resolveObjectKey(prop.key, prop.computed);
		if (!propKey) ctx.error(`${DEFINE_PROPS}() destructure cannot use computed key.`, prop.key);
		if (prop.value.type === "AssignmentPattern") {
			const { left, right } = prop.value;
			if (left.type !== "Identifier") ctx.error(`${DEFINE_PROPS}() destructure does not support nested patterns.`, left);
			registerBinding(propKey, left.name, right);
		} else if (prop.value.type === "Identifier") registerBinding(propKey, prop.value.name);
		else ctx.error(`${DEFINE_PROPS}() destructure does not support nested patterns.`, prop.value);
	} else {
		ctx.propsDestructureRestId = prop.argument.name;
		ctx.bindingMetadata[ctx.propsDestructureRestId] = "setup-reactive-const";
	}
}
function transformDestructuredProps(ctx, vueImportAliases) {
	if (ctx.options.propsDestructure === false) return;
	const rootScope = Object.create(null);
	const scopeStack = [rootScope];
	const functionScopeStack = [rootScope];
	let currentScope = rootScope;
	const excludedIds = /* @__PURE__ */ new WeakSet();
	const parentStack = [];
	const propsLocalToPublicMap = Object.create(null);
	for (const key in ctx.propsDestructuredBindings) {
		const { local } = ctx.propsDestructuredBindings[key];
		rootScope[local] = true;
		propsLocalToPublicMap[local] = key;
	}
	function pushScope(isFunctionScope = false) {
		const scope = currentScope = Object.create(currentScope);
		scopeStack.push(scope);
		if (isFunctionScope) functionScopeStack.push(scope);
	}
	function popScope(isFunctionScope = false) {
		scopeStack.pop();
		if (isFunctionScope) functionScopeStack.pop();
		currentScope = scopeStack[scopeStack.length - 1] || null;
	}
	function registerLocalBinding(id, scope = currentScope) {
		excludedIds.add(id);
		if (scope) scope[id.name] = false;
		else ctx.error("registerBinding called without active scope, something is wrong.", id);
	}
	function walkScope(node, isRoot = false) {
		for (const stmt of node.body) if (stmt.type === "VariableDeclaration") walkVariableDeclaration(stmt, isRoot);
		else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
			if (stmt.declare || !stmt.id) continue;
			registerLocalBinding(stmt.id);
		} else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && stmt.declaration.type === "VariableDeclaration") walkVariableDeclaration(stmt.declaration, isRoot);
		else if (stmt.type === "LabeledStatement" && stmt.body.type === "VariableDeclaration") walkVariableDeclaration(stmt.body, isRoot);
	}
	function walkVariableDeclaration(stmt, isRoot = false, scope = stmt.kind === "var" ? functionScopeStack[functionScopeStack.length - 1] : currentScope) {
		if (stmt.declare) return;
		for (const decl of stmt.declarations) {
			const isDefineProps = isRoot && decl.init && isCallOf(unwrapTSNode(decl.init), "defineProps");
			for (const id of extractIdentifiers(decl.id)) if (isDefineProps) excludedIds.add(id);
			else registerLocalBinding(id, scope);
		}
	}
	function walkFunctionScopeVarDeclarations(scopeNode, isRoot = false) {
		const scope = functionScopeStack[functionScopeStack.length - 1];
		walk$2(scopeNode, { enter(node, parent) {
			if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) return this.skip();
			if (isFunctionType(node) || node.type === "ClassDeclaration" || node.type === "ClassExpression") return this.skip();
			if (node.type === "VariableDeclaration" && node.kind === "var") walkVariableDeclaration(node, isRoot && parent === scopeNode, scope);
		} });
	}
	function rewriteId(id, parent, parentStack) {
		if (parent.type === "AssignmentExpression" && id === parent.left || parent.type === "UpdateExpression") ctx.error(`Cannot assign to destructured props as they are readonly.`, id);
		if (isStaticProperty(parent) && parent.shorthand) {
			if (!parent.inPattern || isInDestructureAssignment(parent, parentStack)) ctx.s.appendLeft(id.end + ctx.startOffset, `: ${genPropsAccessExp(propsLocalToPublicMap[id.name])}`);
		} else ctx.s.overwrite(id.start + ctx.startOffset, id.end + ctx.startOffset, genPropsAccessExp(propsLocalToPublicMap[id.name]));
	}
	function checkUsage(node, method, alias = method) {
		if (isCallOf(node, alias)) {
			const arg = unwrapTSNode(node.arguments[0]);
			if (arg.type === "Identifier" && currentScope[arg.name]) ctx.error(`"${arg.name}" is a destructured prop and should not be passed directly to ${method}(). Pass a getter () => ${arg.name} instead.`, arg);
		}
	}
	const ast = ctx.scriptSetupAst;
	walkFunctionScopeVarDeclarations(ast, true);
	walkScope(ast, true);
	walk$2(ast, {
		enter(node, parent) {
			parent && parentStack.push(parent);
			if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) return this.skip();
			checkUsage(node, "watch", vueImportAliases.watch);
			checkUsage(node, "toRef", vueImportAliases.toRef);
			if (isFunctionType(node)) {
				pushScope(true);
				walkFunctionParams(node, registerLocalBinding);
				if (node.body.type === "BlockStatement") {
					walkFunctionScopeVarDeclarations(node.body);
					walkScope(node.body);
				}
				return;
			}
			if (node.type === "CatchClause") {
				pushScope();
				if (node.param && node.param.type === "Identifier") registerLocalBinding(node.param);
				walkScope(node.body);
				return;
			}
			if (node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "ForStatement") {
				pushScope();
				const varDecl = node.type === "ForStatement" ? node.init : node.left;
				if (varDecl && varDecl.type === "VariableDeclaration") walkVariableDeclaration(varDecl);
				if (node.body.type === "BlockStatement") walkScope(node.body);
				return;
			}
			if (node.type === "BlockStatement" && !isFunctionType(parent)) {
				pushScope();
				walkScope(node);
				return;
			}
			if (node.type === "Identifier") {
				if (isReferencedIdentifier(node, parent, parentStack) && !excludedIds.has(node)) {
					if (currentScope[node.name]) rewriteId(node, parent, parentStack);
				}
			}
		},
		leave(node, parent) {
			parent && parentStack.pop();
			if (isFunctionType(node)) popScope(true);
			else if (node.type === "BlockStatement" && !isFunctionType(parent)) popScope();
			else if (node.type === "CatchClause" || node.type === "ForOfStatement" || node.type === "ForInStatement" || node.type === "ForStatement") popScope();
		}
	});
}
//#endregion
//#region packages/compiler-sfc/src/script/defineEmits.ts
const DEFINE_EMITS = "defineEmits";
function processDefineEmits(ctx, node, declId) {
	if (!isCallOf(node, "defineEmits")) return false;
	if (ctx.hasDefineEmitCall) ctx.error(`duplicate ${DEFINE_EMITS}() call`, node);
	ctx.hasDefineEmitCall = true;
	ctx.emitsRuntimeDecl = node.arguments[0];
	if (node.typeParameters) {
		if (ctx.emitsRuntimeDecl) ctx.error(`${DEFINE_EMITS}() cannot accept both type and non-type arguments at the same time. Use one or the other.`, node);
		ctx.emitsTypeDecl = node.typeParameters.params[0];
	}
	ctx.emitDecl = declId;
	return true;
}
function genRuntimeEmits(ctx) {
	let emitsDecl = "";
	if (ctx.emitsRuntimeDecl) emitsDecl = ctx.getString(ctx.emitsRuntimeDecl).trim();
	else if (ctx.emitsTypeDecl) {
		const typeDeclaredEmits = extractRuntimeEmits(ctx);
		emitsDecl = typeDeclaredEmits.size ? `[${Array.from(typeDeclaredEmits).map((k) => JSON.stringify(k)).join(", ")}]` : ``;
	}
	if (ctx.hasDefineModelCall) {
		let modelEmitsDecl = `[${Object.keys(ctx.modelDecls).map((n) => JSON.stringify(`update:${n}`)).join(", ")}]`;
		emitsDecl = emitsDecl ? `/*@__PURE__*/${ctx.helper("mergeModels")}(${emitsDecl}, ${modelEmitsDecl})` : modelEmitsDecl;
	}
	return emitsDecl;
}
function extractRuntimeEmits(ctx) {
	const emits = /* @__PURE__ */ new Set();
	const node = ctx.emitsTypeDecl;
	if (node.type === "TSFunctionType") {
		extractEventNames(ctx, node.parameters[0], emits);
		return emits;
	}
	const { props, calls } = resolveTypeElements(ctx, node);
	let hasProperty = false;
	for (const key in props) {
		emits.add(key);
		hasProperty = true;
	}
	if (calls) {
		if (hasProperty) ctx.error(`defineEmits() type cannot mixed call signature and property syntax.`, node);
		for (const call of calls) extractEventNames(ctx, call.parameters[0], emits);
	}
	return emits;
}
function extractEventNames(ctx, eventName, emits) {
	if (eventName.type === "Identifier" && eventName.typeAnnotation && eventName.typeAnnotation.type === "TSTypeAnnotation") {
		const types = resolveUnionType(ctx, eventName.typeAnnotation.typeAnnotation);
		for (const type of types) if (type.type === "TSLiteralType") {
			if (type.literal.type !== "UnaryExpression" && type.literal.type !== "TemplateLiteral") emits.add(String(type.literal.value));
		}
	}
}
//#endregion
//#region packages/compiler-sfc/src/script/defineExpose.ts
const DEFINE_EXPOSE = "defineExpose";
function processDefineExpose(ctx, node) {
	if (isCallOf(node, "defineExpose")) {
		if (ctx.hasDefineExposeCall) ctx.error(`duplicate ${DEFINE_EXPOSE}() call`, node);
		ctx.hasDefineExposeCall = true;
		return true;
	}
	return false;
}
//#endregion
//#region packages/compiler-sfc/src/script/defineSlots.ts
const DEFINE_SLOTS = "defineSlots";
function processDefineSlots(ctx, node, declId) {
	if (!isCallOf(node, "defineSlots")) return false;
	if (ctx.hasDefineSlotsCall) ctx.error(`duplicate ${DEFINE_SLOTS}() call`, node);
	ctx.hasDefineSlotsCall = true;
	if (node.arguments.length > 0) ctx.error(`${DEFINE_SLOTS}() cannot accept arguments`, node);
	if (declId) ctx.s.overwrite(ctx.startOffset + node.start, ctx.startOffset + node.end, `${ctx.helper("useSlots")}()`);
	return true;
}
//#endregion
//#region packages/compiler-sfc/src/script/defineOptions.ts
const DEFINE_OPTIONS = "defineOptions";
function processDefineOptions(ctx, node) {
	if (!isCallOf(node, "defineOptions")) return false;
	if (ctx.hasDefineOptionsCall) ctx.error(`duplicate ${DEFINE_OPTIONS}() call`, node);
	if (node.typeParameters) ctx.error(`${DEFINE_OPTIONS}() cannot accept type arguments`, node);
	if (!node.arguments[0]) return true;
	ctx.hasDefineOptionsCall = true;
	ctx.optionsRuntimeDecl = unwrapTSNode(node.arguments[0]);
	let propsOption = void 0;
	let emitsOption = void 0;
	let exposeOption = void 0;
	let slotsOption = void 0;
	if (ctx.optionsRuntimeDecl.type === "ObjectExpression") {
		for (const prop of ctx.optionsRuntimeDecl.properties) if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") switch (prop.key.name) {
			case "props":
				propsOption = prop;
				break;
			case "emits":
				emitsOption = prop;
				break;
			case "expose":
				exposeOption = prop;
				break;
			case "slots": slotsOption = prop;
		}
	}
	if (propsOption) ctx.error(`${DEFINE_OPTIONS}() cannot be used to declare props. Use ${DEFINE_PROPS}() instead.`, propsOption);
	if (emitsOption) ctx.error(`${DEFINE_OPTIONS}() cannot be used to declare emits. Use ${DEFINE_EMITS}() instead.`, emitsOption);
	if (exposeOption) ctx.error(`${DEFINE_OPTIONS}() cannot be used to declare expose. Use ${DEFINE_EXPOSE}() instead.`, exposeOption);
	if (slotsOption) ctx.error(`${DEFINE_OPTIONS}() cannot be used to declare slots. Use ${DEFINE_SLOTS}() instead.`, slotsOption);
	return true;
}
//#endregion
//#region packages/compiler-sfc/src/script/topLevelAwait.ts
/**
* Support context-persistence between top-level await expressions:
*
* ```js
* const instance = getCurrentInstance()
* await foo()
* expect(getCurrentInstance()).toBe(instance)
* ```
*
* In the future we can potentially get rid of this when Async Context
* becomes generally available: https://github.com/tc39/proposal-async-context
*
* ```js
* // input
* await foo()
* // output
* ;(
*   ([__temp,__restore] = withAsyncContext(() => foo())),
*   await __temp,
*   __restore()
* )
*
* // input
* const a = await foo()
* // output
* const a = (
*   ([__temp, __restore] = withAsyncContext(() => foo())),
*   __temp = await __temp,
*   __restore(),
*   __temp
* )
* ```
*/
function processAwait(ctx, node, needSemi, isStatement) {
	const argumentStart = node.argument.extra && node.argument.extra.parenthesized ? node.argument.extra.parenStart : node.argument.start;
	const startOffset = ctx.startOffset;
	const argumentStr = ctx.descriptor.source.slice(argumentStart + startOffset, node.argument.end + startOffset);
	const containsNestedAwait = /\bawait\b/.test(argumentStr);
	ctx.s.overwrite(node.start + startOffset, argumentStart + startOffset, `${needSemi ? `;` : ``}(\n  ([__temp,__restore] = ${ctx.helper(`withAsyncContext`)}(${containsNestedAwait ? `async ` : ``}() => `);
	ctx.s.appendLeft(node.end + startOffset, `)),\n  ${isStatement ? `` : `__temp = `}await __temp,\n  __restore()${isStatement ? `` : `,\n  __temp`}\n)`);
}
//#endregion
//#region packages/compiler-sfc/src/compileScript.ts
init_objectSpread2();
const MACROS = [
	DEFINE_PROPS,
	DEFINE_EMITS,
	DEFINE_EXPOSE,
	DEFINE_OPTIONS,
	DEFINE_SLOTS,
	DEFINE_MODEL,
	WITH_DEFAULTS
];
/**
* Compile `<script setup>`
* It requires the whole SFC descriptor because we need to handle and merge
* normal `<script>` + `<script setup>` if both are present.
*/
function compileScript(sfc, options) {
	var _options$templateOpti;
	if (!options.id) warnOnce("compileScript now requires passing the `id` option.\nUpgrade your vite or vue-loader version for compatibility with the latest experimental proposals.");
	const { script, scriptSetup, source, filename } = sfc;
	const hoistStatic = options.hoistStatic !== false && !script;
	const scopeId = options.id ? options.id.replace(/^data-v-/, "") : "";
	const scriptLang = script && script.lang;
	const scriptSetupLang = scriptSetup && scriptSetup.lang;
	const vapor = sfc.vapor || options.vapor;
	const ssr = (_options$templateOpti = options.templateOptions) === null || _options$templateOpti === void 0 ? void 0 : _options$templateOpti.ssr;
	const setupPreambleLines = [];
	const cssModuleBindings = [];
	let cssModuleHelper = "_useCssModule";
	const isJSOrTS = isJS(scriptLang, scriptSetupLang) || isTS(scriptLang, scriptSetupLang);
	if (script && scriptSetup && scriptLang !== scriptSetupLang) throw new Error("[@vue/compiler-sfc] <script> and <script setup> must have the same language type.");
	if (!scriptSetup) {
		if (!script) throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`);
		if (script.lang && !isJSOrTS) return script;
		return processNormalScript(new ScriptCompileContext(sfc, options), scopeId);
	}
	if (scriptSetupLang && !isJSOrTS) return scriptSetup;
	const ctx = new ScriptCompileContext(sfc, options);
	const scriptBindings = Object.create(null);
	const setupBindings = Object.create(null);
	let defaultExport;
	let hasAwait = false;
	let hasInlinedSsrRenderFn = false;
	const startOffset = ctx.startOffset;
	const endOffset = ctx.endOffset;
	const scriptStartOffset = script && script.loc.start.offset;
	const scriptEndOffset = script && script.loc.end.offset;
	function hoistNode(node) {
		const start = node.start + startOffset;
		let end = node.end + startOffset;
		if (node.trailingComments && node.trailingComments.length > 0) end = node.trailingComments[node.trailingComments.length - 1].end + startOffset;
		while (end <= source.length) {
			if (!/\s/.test(source.charAt(end))) break;
			end++;
		}
		ctx.s.move(start, end, 0);
	}
	function registerUserImport(source, local, imported, isType, isFromSetup, needTemplateUsageCheck) {
		let isImportUsed = needTemplateUsageCheck;
		if (needTemplateUsageCheck && ctx.isTS && sfc.template && !sfc.template.src && !sfc.template.lang) isImportUsed = isUsedInTemplate(local, sfc, options.templateOptions);
		ctx.userImports[local] = {
			isType,
			imported,
			local,
			source,
			isFromSetup,
			isUsedInTemplate: isImportUsed
		};
	}
	function checkInvalidScopeReference(node, method) {
		if (!node) return;
		walkIdentifiers(node, (id) => {
			const binding = setupBindings[id.name];
			if (binding && binding !== "literal-const") ctx.error(`\`${method}()\` in <script setup> cannot reference locally declared variables because it will be hoisted outside of the setup() function. If your component options require initialization in the module scope, use a separate normal <script> to export the options instead.`, id);
		});
	}
	function buildDestructureElements() {
		if (!sfc.template || !sfc.template.ast) return;
		const builtins = {
			$props: {
				bindingType: "setup-reactive-const",
				setup: () => setupPreambleLines.push(`const $props = __props`)
			},
			$emit: {
				bindingType: "setup-const",
				setup: () => ctx.emitDecl ? setupPreambleLines.push(`const $emit = __emit`) : destructureElements.push("emit: $emit")
			},
			$attrs: {
				bindingType: "setup-reactive-const",
				setup: () => destructureElements.push("attrs: $attrs")
			},
			$slots: {
				bindingType: "setup-reactive-const",
				setup: () => destructureElements.push("slots: $slots")
			}
		};
		for (const [name, config] of Object.entries(builtins)) if (isUsedInTemplate(name, sfc) && !ctx.bindingMetadata[name]) {
			config.setup();
			ctx.bindingMetadata[name] = config.bindingType;
		}
	}
	/**
	* vapor resolves template expressions against setup scope instead of a
	* `_ctx` render proxy, so `<style module>` names need explicit bindings.
	*/
	function declareTemplateCssModules() {
		if (!sfc.template) return;
		while (ctx.bindingMetadata[cssModuleHelper] || inlineMode && sfc.styles.some((style) => style.module === cssModuleHelper)) cssModuleHelper += "_";
		for (const style of sfc.styles) {
			var _options$templateOpti2;
			if (!style.module) continue;
			const name = style.module === true ? `$style` : style.module;
			if (!isSimpleIdentifier(name) || ctx.bindingMetadata[name] || inlineMode && sfc.template.ast && !sfc.template.lang && !((_options$templateOpti2 = options.templateOptions) === null || _options$templateOpti2 === void 0 ? void 0 : _options$templateOpti2.preprocessLang) && !isUsedInTemplate(name, sfc, options.templateOptions)) continue;
			if (inlineMode) {
				if (name === "__props" || name === "_useCssModule" || name[0] === "_" && ctx.helperImports.has(name.slice(1))) continue;
				try {
					(0, import_lib.parse)(`const ${name} = null`, { sourceType: "module" });
				} catch (_unused) {
					continue;
				}
			}
			ctx.helperImports.add("useCssModule");
			const value = `${cssModuleHelper}(${JSON.stringify(name)})`;
			cssModuleBindings.push(inlineMode ? `const ${name} = ${value}` : `${JSON.stringify(name)}: ${value}`);
			ctx.bindingMetadata[name] = "setup-const";
		}
	}
	const scriptAst = ctx.scriptAst;
	const scriptSetupAst = ctx.scriptSetupAst;
	const inlineMode = options.inlineTemplate;
	if (scriptAst) {
		for (const node of scriptAst.body) if (node.type === "ImportDeclaration") for (const specifier of node.specifiers) {
			const imported = getImportedName(specifier);
			registerUserImport(node.source.value, specifier.local.name, imported, node.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type", false, !inlineMode);
		}
	}
	for (const node of scriptSetupAst.body) if (node.type === "ImportDeclaration") {
		hoistNode(node);
		let removed = 0;
		const removeSpecifier = (i) => {
			const removeLeft = i > removed;
			removed++;
			const current = node.specifiers[i];
			const next = node.specifiers[i + 1];
			ctx.s.remove(removeLeft ? node.specifiers[i - 1].end + startOffset : current.start + startOffset, next && !removeLeft ? next.start + startOffset : current.end + startOffset);
		};
		for (let i = 0; i < node.specifiers.length; i++) {
			const specifier = node.specifiers[i];
			const local = specifier.local.name;
			const imported = getImportedName(specifier);
			const source = node.source.value;
			const existing = ctx.userImports[local];
			if (source === "vue" && MACROS.includes(imported)) {
				if (local === imported) warnOnce(`\`${imported}\` is a compiler macro and no longer needs to be imported.`);
				else ctx.error(`\`${imported}\` is a compiler macro and cannot be aliased to a different name.`, specifier);
				removeSpecifier(i);
			} else if (existing) {
				if (existing.source === source && existing.imported === imported) removeSpecifier(i);
				else ctx.error(`different imports aliased to same local name.`, specifier);
			} else registerUserImport(source, local, imported, node.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type", true, !inlineMode);
		}
		if (node.specifiers.length && removed === node.specifiers.length) ctx.s.remove(node.start + startOffset, node.end + startOffset);
	}
	const vueImportAliases = {};
	for (const key in ctx.userImports) {
		const { source, imported, local } = ctx.userImports[key];
		if (source === "vue") vueImportAliases[imported] = local;
	}
	if (script && scriptAst) {
		for (const node of scriptAst.body) if (node.type === "ExportDefaultDeclaration") {
			defaultExport = node;
			let optionProperties;
			if (defaultExport.declaration.type === "ObjectExpression") optionProperties = defaultExport.declaration.properties;
			else if (defaultExport.declaration.type === "CallExpression" && defaultExport.declaration.arguments[0] && defaultExport.declaration.arguments[0].type === "ObjectExpression") optionProperties = defaultExport.declaration.arguments[0].properties;
			if (optionProperties) for (const p of optionProperties) {
				if (p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "name") ctx.hasDefaultExportName = true;
				if ((p.type === "ObjectMethod" || p.type === "ObjectProperty") && p.key.type === "Identifier" && p.key.name === "render") ctx.hasDefaultExportRender = true;
			}
			const start = node.start + scriptStartOffset;
			const end = node.declaration.start + scriptStartOffset;
			ctx.s.overwrite(start, end, `const ${normalScriptDefaultVar} = `);
		} else if (node.type === "ExportNamedDeclaration") {
			const defaultSpecifier = node.specifiers.find((s) => s.exported.type === "Identifier" && s.exported.name === "default");
			if (defaultSpecifier) {
				defaultExport = node;
				if (node.specifiers.length > 1) ctx.s.remove(defaultSpecifier.start + scriptStartOffset, defaultSpecifier.end + scriptStartOffset);
				else ctx.s.remove(node.start + scriptStartOffset, node.end + scriptStartOffset);
				if (node.source) ctx.s.prepend(`import { ${defaultSpecifier.local.name} as ${normalScriptDefaultVar} } from '${node.source.value}'\n`);
				else ctx.s.appendLeft(scriptEndOffset, `\nconst ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}\n`);
			}
			if (node.declaration) walkDeclaration("script", node.declaration, scriptBindings, vueImportAliases, hoistStatic);
		} else if ((node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration") && !node.declare) walkDeclaration("script", node, scriptBindings, vueImportAliases, hoistStatic);
		if (scriptStartOffset > startOffset) {
			if (!/\n$/.test(script.content.trim())) ctx.s.appendLeft(scriptEndOffset, `\n`);
			ctx.s.move(scriptStartOffset, scriptEndOffset, 0);
		}
	}
	for (const node of scriptSetupAst.body) {
		if (node.type === "ExpressionStatement") {
			const expr = unwrapTSNode(node.expression);
			if (processDefineProps(ctx, expr) || processDefineEmits(ctx, expr) || processDefineOptions(ctx, expr) || processDefineSlots(ctx, expr)) ctx.s.remove(node.start + startOffset, node.end + startOffset);
			else if (processDefineExpose(ctx, expr)) {
				const callee = expr.callee;
				ctx.s.overwrite(callee.start + startOffset, callee.end + startOffset, "__expose");
			} else processDefineModel(ctx, expr);
		}
		if (node.type === "VariableDeclaration" && !node.declare) {
			const total = node.declarations.length;
			let left = total;
			let lastNonRemoved;
			for (let i = 0; i < total; i++) {
				const decl = node.declarations[i];
				const init = decl.init && unwrapTSNode(decl.init);
				if (init) {
					if (processDefineOptions(ctx, init)) ctx.error(`${DEFINE_OPTIONS}() has no returning value, it cannot be assigned.`, node);
					const isDefineProps = processDefineProps(ctx, init, decl.id);
					if (ctx.propsDestructureRestId) setupBindings[ctx.propsDestructureRestId] = "setup-reactive-const";
					const isDefineEmits = !isDefineProps && processDefineEmits(ctx, init, decl.id);
					!isDefineEmits && (processDefineSlots(ctx, init, decl.id) || processDefineModel(ctx, init, decl.id));
					if (isDefineProps && !ctx.propsDestructureRestId && ctx.propsDestructureDecl) {
						if (left === 1) ctx.s.remove(node.start + startOffset, node.end + startOffset);
						else {
							let start = decl.start + startOffset;
							let end = decl.end + startOffset;
							if (i === total - 1) start = node.declarations[lastNonRemoved].end + startOffset;
							else end = node.declarations[i + 1].start + startOffset;
							ctx.s.remove(start, end);
							left--;
						}
					} else if (isDefineEmits) ctx.s.overwrite(startOffset + init.start, startOffset + init.end, "__emit");
					else lastNonRemoved = i;
				}
			}
		}
		let isAllLiteral = false;
		if ((node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration") && !node.declare) isAllLiteral = walkDeclaration("scriptSetup", node, setupBindings, vueImportAliases, hoistStatic, !!ctx.propsDestructureDecl);
		if (hoistStatic && isAllLiteral) hoistNode(node);
		if (node.type === "VariableDeclaration" && !node.declare || node.type.endsWith("Statement")) {
			const scope = [scriptSetupAst.body];
			walk$2(node, {
				enter(child, parent) {
					if (isFunctionType(child)) this.skip();
					if (child.type === "BlockStatement") scope.push(child.body);
					else if (child.type === "SwitchCase") scope.push(child.consequent);
					if (child.type === "AwaitExpression") {
						hasAwait = true;
						const needsSemi = scope[scope.length - 1].some((n, i) => {
							return (scope.length === 1 || i > 0) && n.type === "ExpressionStatement" && n.start === child.start;
						});
						processAwait(ctx, child, needsSemi, parent.type === "ExpressionStatement");
					}
				},
				leave(node) {
					if (node.type === "BlockStatement" || node.type === "SwitchCase") scope.pop();
				}
			});
		}
		if (node.type === "ExportNamedDeclaration" && node.exportKind !== "type" || node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration") ctx.error("<script setup> cannot contain ES module exports. If you are using a previous version of <script setup>, please consult the updated RFC at https://github.com/vuejs/rfcs/pull/227.", node);
		if (ctx.isTS) {
			if (node.type.startsWith("TS") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "VariableDeclaration" && node.declare) {
				if (node.type !== "TSEnumDeclaration") hoistNode(node);
			}
		}
	}
	if (ctx.propsDestructureDecl) transformDestructuredProps(ctx, vueImportAliases);
	checkInvalidScopeReference(ctx.propsRuntimeDecl, DEFINE_PROPS);
	checkInvalidScopeReference(ctx.propsRuntimeDefaults, DEFINE_PROPS);
	checkInvalidScopeReference(ctx.propsDestructureDecl, DEFINE_PROPS);
	checkInvalidScopeReference(ctx.emitsRuntimeDecl, DEFINE_EMITS);
	checkInvalidScopeReference(ctx.optionsRuntimeDecl, DEFINE_OPTIONS);
	for (const { runtimeOptionNodes } of Object.values(ctx.modelDecls)) for (const node of runtimeOptionNodes) checkInvalidScopeReference(node, DEFINE_MODEL);
	if (script) {
		if (startOffset < scriptStartOffset) {
			ctx.s.remove(0, startOffset);
			ctx.s.remove(endOffset, scriptStartOffset);
			ctx.s.remove(scriptEndOffset, source.length);
		} else {
			ctx.s.remove(0, scriptStartOffset);
			ctx.s.remove(scriptEndOffset, startOffset);
			ctx.s.remove(endOffset, source.length);
		}
	} else {
		ctx.s.remove(0, startOffset);
		ctx.s.remove(endOffset, source.length);
	}
	if (scriptAst) Object.assign(ctx.bindingMetadata, analyzeScriptBindings(scriptAst.body));
	for (const [key, { isType, imported, source }] of Object.entries(ctx.userImports)) {
		if (isType) continue;
		ctx.bindingMetadata[key] = imported === "*" || imported === "default" && source.endsWith(".vue") || source === "vue" ? "setup-const" : "setup-maybe-ref";
	}
	for (const key in scriptBindings) ctx.bindingMetadata[key] = scriptBindings[key];
	for (const key in setupBindings) ctx.bindingMetadata[key] = setupBindings[key];
	if (sfc.template && !sfc.template.src && sfc.template.ast) {
		const vModelIds = resolveTemplateVModelIdentifiers(sfc, options.templateOptions);
		if (vModelIds.size) {
			const toDemote = /* @__PURE__ */ new Set();
			for (const id of vModelIds) if (setupBindings[id] === "setup-reactive-const") toDemote.add(id);
			if (toDemote.size) {
				for (const node of scriptSetupAst.body) if (node.type === "VariableDeclaration" && node.kind === "const" && !node.declare) {
					const demotedInDecl = [];
					for (const decl of node.declarations) if (decl.id.type === "Identifier" && toDemote.has(decl.id.name)) demotedInDecl.push(decl.id.name);
					if (demotedInDecl.length) {
						ctx.s.overwrite(node.start + startOffset, node.start + startOffset + 5, "let");
						for (const id of demotedInDecl) {
							setupBindings[id] = "setup-let";
							ctx.bindingMetadata[id] = "setup-let";
							warnOnce(`\`v-model\` cannot update a \`const\` reactive binding \`${id}\`. The compiler has transformed it to \`let\` to make the update work.`);
						}
					}
				}
			}
		}
	}
	if (sfc.cssVars.length && !ssr) {
		ctx.helperImports.add(getCssVarsHelper(vapor));
		ctx.helperImports.add("unref");
		ctx.s.prependLeft(startOffset, `\n${genCssVarsCode(sfc.cssVars, ctx.bindingMetadata, scopeId, !!options.isProd, vapor)}\n`);
	}
	let args = `__props`;
	if (ctx.propsTypeDecl) args += `: any`;
	if (ctx.propsDecl) {
		if (ctx.propsDestructureRestId) {
			ctx.s.overwrite(startOffset + ctx.propsCall.start, startOffset + ctx.propsCall.end, `${ctx.helper(`createPropsRestProxy`)}(__props, ${JSON.stringify(Object.keys(ctx.propsDestructuredBindings))})`);
			ctx.s.overwrite(startOffset + ctx.propsDestructureDecl.start, startOffset + ctx.propsDestructureDecl.end, ctx.propsDestructureRestId);
		} else if (!ctx.propsDestructureDecl) ctx.s.overwrite(startOffset + ctx.propsCall.start, startOffset + ctx.propsCall.end, "__props");
	}
	if (hasAwait) {
		const any = ctx.isTS ? `: any` : ``;
		ctx.s.prependLeft(startOffset, `\nlet __temp${any}, __restore${any}\n`);
	}
	const destructureElements = ctx.hasDefineExposeCall || !inlineMode ? [`expose: __expose`] : [];
	if (ctx.emitDecl) destructureElements.push(`emit: __emit`);
	if (inlineMode) buildDestructureElements();
	if (vapor && !ssr) declareTemplateCssModules();
	if (destructureElements.length) args += `, { ${destructureElements.join(", ")} }`;
	let templateMap;
	let templateCode;
	let returned;
	const propsDecl = genRuntimeProps(ctx);
	if (!inlineMode || !sfc.template && ctx.hasDefaultExportRender) {
		const allBindings = _objectSpread2(_objectSpread2({}, scriptBindings), setupBindings);
		for (const key in ctx.userImports) if (!ctx.userImports[key].isType && ctx.userImports[key].isUsedInTemplate) allBindings[key] = true;
		returned = `{ `;
		for (const key in allBindings) if (allBindings[key] === true && ctx.userImports[key].source !== "vue" && !ctx.userImports[key].source.endsWith(".vue")) returned += `get ${key}() { return ${key} }, `;
		else if (ctx.bindingMetadata[key] === "setup-let") {
			const setArg = key === "v" ? `_v` : `v`;
			returned += `get ${key}() { return ${key} }, set ${key}(${setArg}) { ${key} = ${setArg} }, `;
		} else returned += `${key}, `;
		returned += cssModuleBindings.join(", ");
		returned = returned.replace(/, $/, "") + ` }`;
	} else if (sfc.template && !sfc.template.src) {
		if (ssr) hasInlinedSsrRenderFn = true;
		const { code, preamble, tips, errors, helpers, map } = compileTemplate(_objectSpread2(_objectSpread2({
			filename,
			ast: sfc.template.ast,
			source: sfc.template.content,
			inMap: sfc.template.map
		}, options.templateOptions), {}, {
			id: scopeId,
			scoped: sfc.styles.some((s) => s.scoped),
			isProd: options.isProd,
			ssrCssVars: sfc.cssVars,
			vapor,
			compilerOptions: _objectSpread2(_objectSpread2({}, options.templateOptions && options.templateOptions.compilerOptions), {}, {
				inline: true,
				isTS: ctx.isTS,
				bindingMetadata: ctx.bindingMetadata
			})
		}));
		templateMap = map;
		templateCode = code;
		if (tips.length) tips.forEach(warnOnce);
		const err = errors[0];
		if (typeof err === "string") throw new Error(err);
		else if (err) {
			if (err.loc) err.message += `\n\n` + sfc.filename + "\n" + generateCodeFrame(source, err.loc.start.offset, err.loc.end.offset) + `\n`;
			throw err;
		}
		if (preamble) ctx.s.prepend(preamble);
		if (helpers && (helpers.has(UNREF) || helpers.has("unref"))) ctx.helperImports.delete("unref");
		returned = vapor && !ssr && hasAwait ? `return () => {${code}}` : code;
		if (cssModuleBindings.length) returned = `{\n${cssModuleBindings.join("\n")}\n${returned}\n}`;
	} else returned = `() => {}`;
	if (!inlineMode && true) ctx.s.appendRight(endOffset, `\nconst __returned__ = ${returned}\nObject.defineProperty(__returned__, '__isScriptSetup', { enumerable: false, value: true })\nreturn __returned__\n}\n\n`);
	else ctx.s.appendRight(endOffset, `\n${vapor && !ssr && inlineMode ? `` : `return `}${returned}\n}\n\n`);
	const genDefaultAs = options.genDefaultAs ? `const ${options.genDefaultAs} =` : `export default`;
	let runtimeOptions = ``;
	if (!ctx.hasDefaultExportName && filename && filename !== "anonymous.vue") {
		const match = filename.match(/([^/\\]+)\.\w+$/);
		if (match) runtimeOptions += `\n  __name: '${match[1]}',`;
	}
	if (hasInlinedSsrRenderFn) runtimeOptions += `\n  __ssrInlineRender: true,`;
	if (propsDecl) runtimeOptions += `\n  props: ${propsDecl},`;
	const emitsDecl = genRuntimeEmits(ctx);
	if (emitsDecl) runtimeOptions += `\n  emits: ${emitsDecl},`;
	if (vapor && !ssr && sfc.template && !sfc.template.src) {
		var _options$templateOpti3;
		if (isMultiRoot(sfc.template.ast, (_options$templateOpti3 = options.templateOptions) === null || _options$templateOpti3 === void 0 ? void 0 : _options$templateOpti3.compilerOptions)) runtimeOptions += `\n  __multiRoot: true,`;
	}
	let definedOptions = "";
	if (ctx.optionsRuntimeDecl) definedOptions = scriptSetup.content.slice(ctx.optionsRuntimeDecl.start, ctx.optionsRuntimeDecl.end).trim();
	if (!ctx.hasDefineExposeCall && !inlineMode) setupPreambleLines.push(`__expose();`);
	const setupPreamble = setupPreambleLines.length ? `  ${setupPreambleLines.join("\n  ")}\n` : "";
	if (ctx.isTS) {
		if (ssr && vapor) runtimeOptions += `\n  __vapor: true,`;
		const def = (defaultExport ? `\n  ...${normalScriptDefaultVar},` : ``) + (definedOptions ? `\n  ...${definedOptions},` : "");
		ctx.s.prependLeft(startOffset, `\n${genDefaultAs} /*@__PURE__*/${ctx.helper(vapor && !ssr ? `defineVaporComponent` : `defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${setupPreamble}`);
		ctx.s.appendRight(endOffset, `})`);
	} else {
		if (vapor) runtimeOptions += `\n  __vapor: true,`;
		if (defaultExport || definedOptions) {
			ctx.s.prependLeft(startOffset, `\n${genDefaultAs} /*@__PURE__*/Object.assign(${defaultExport ? `${normalScriptDefaultVar}, ` : ""}${definedOptions ? `${definedOptions}, ` : ""}{${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${setupPreamble}`);
			ctx.s.appendRight(endOffset, `})`);
		} else {
			ctx.s.prependLeft(startOffset, `\n${genDefaultAs} {${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${setupPreamble}`);
			ctx.s.appendRight(endOffset, `}`);
		}
	}
	if (ctx.helperImports.size > 0) {
		var _options$templateOpti4;
		const runtimeModuleName = (_options$templateOpti4 = options.templateOptions) === null || _options$templateOpti4 === void 0 || (_options$templateOpti4 = _options$templateOpti4.compilerOptions) === null || _options$templateOpti4 === void 0 ? void 0 : _options$templateOpti4.runtimeModuleName;
		const importSrc = runtimeModuleName ? JSON.stringify(runtimeModuleName) : `'vue'`;
		ctx.s.prepend(`import { ${[...ctx.helperImports].map((h) => `${h} as ${h === "useCssModule" ? cssModuleHelper : `_${h}`}`).join(", ")} } from ${importSrc}\n`);
	}
	const content = ctx.s.toString();
	let map = options.sourceMap !== false ? ctx.s.generateMap({
		source: filename,
		hires: true,
		includeContent: true
	}) : void 0;
	if (templateMap && map) {
		const offset = content.indexOf(templateCode);
		const templateLineOffset = content.slice(0, offset).split(/\r?\n/).length - 1;
		map = mergeSourceMaps(map, templateMap, templateLineOffset);
	}
	return _objectSpread2(_objectSpread2({}, scriptSetup), {}, {
		bindings: ctx.bindingMetadata,
		imports: ctx.userImports,
		content,
		map,
		scriptAst: scriptAst === null || scriptAst === void 0 ? void 0 : scriptAst.body,
		scriptSetupAst: scriptSetupAst === null || scriptSetupAst === void 0 ? void 0 : scriptSetupAst.body,
		deps: ctx.deps ? [...ctx.deps] : void 0
	});
}
function registerBinding(bindings, node, type) {
	bindings[node.name] = type;
}
function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic, isPropsDestructureEnabled = false) {
	let isAllLiteral = false;
	if (node.type === "VariableDeclaration") {
		const isConst = node.kind === "const";
		isAllLiteral = isConst && node.declarations.every((decl) => decl.id.type === "Identifier" && isStaticNode(decl.init));
		for (const { id, init: _init } of node.declarations) {
			const init = _init && unwrapTSNode(_init);
			const isConstMacroCall = isConst && isCallOf(init, (c) => c === "defineProps" || c === "defineEmits" || c === "withDefaults" || c === "defineSlots");
			if (id.type === "Identifier") {
				let bindingType;
				const userReactiveBinding = userImportAliases["reactive"];
				if ((hoistStatic || from === "script") && (isAllLiteral || isConst && isStaticNode(init))) bindingType = "literal-const";
				else if (isCallOf(init, userReactiveBinding)) bindingType = isConst ? "setup-reactive-const" : "setup-let";
				else if (isConstMacroCall || isConst && canNeverBeRef(init, userReactiveBinding)) bindingType = isCallOf(init, "defineProps") ? "setup-reactive-const" : "setup-const";
				else if (isConst) {
					if (isCallOf(init, (m) => m === userImportAliases["ref"] || m === userImportAliases["computed"] || m === userImportAliases["shallowRef"] || m === userImportAliases["customRef"] || m === userImportAliases["toRef"] || m === userImportAliases["useTemplateRef"] || m === "defineModel")) bindingType = "setup-ref";
					else bindingType = "setup-maybe-ref";
				} else bindingType = "setup-let";
				registerBinding(bindings, id, bindingType);
			} else {
				if (isCallOf(init, "defineProps") && isPropsDestructureEnabled) continue;
				if (id.type === "ObjectPattern") walkObjectPattern(id, bindings, isConst, isConstMacroCall);
				else if (id.type === "ArrayPattern") walkArrayPattern(id, bindings, isConst, isConstMacroCall);
			}
		}
	} else if (node.type === "TSEnumDeclaration") {
		isAllLiteral = node.members.every((member) => !member.initializer || isStaticNode(member.initializer));
		bindings[node.id.name] = isAllLiteral ? "literal-const" : "setup-const";
	} else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") bindings[node.id.name] = "setup-const";
	return isAllLiteral;
}
function walkObjectPattern(node, bindings, isConst, isDefineCall = false) {
	for (const p of node.properties) if (p.type === "ObjectProperty") {
		if (p.key.type === "Identifier" && p.key === p.value) {
			const type = isDefineCall ? "setup-const" : isConst ? "setup-maybe-ref" : "setup-let";
			registerBinding(bindings, p.key, type);
		} else walkPattern(p.value, bindings, isConst, isDefineCall);
	} else {
		const type = isConst ? "setup-const" : "setup-let";
		registerBinding(bindings, p.argument, type);
	}
}
function walkArrayPattern(node, bindings, isConst, isDefineCall = false) {
	for (const e of node.elements) e && walkPattern(e, bindings, isConst, isDefineCall);
}
function walkPattern(node, bindings, isConst, isDefineCall = false) {
	if (node.type === "Identifier") registerBinding(bindings, node, isDefineCall ? "setup-const" : isConst ? "setup-maybe-ref" : "setup-let");
	else if (node.type === "RestElement") {
		const type = isConst ? "setup-const" : "setup-let";
		registerBinding(bindings, node.argument, type);
	} else if (node.type === "ObjectPattern") walkObjectPattern(node, bindings, isConst);
	else if (node.type === "ArrayPattern") walkArrayPattern(node, bindings, isConst);
	else if (node.type === "AssignmentPattern") {
		if (node.left.type === "Identifier") {
			const type = isDefineCall ? "setup-const" : isConst ? "setup-maybe-ref" : "setup-let";
			registerBinding(bindings, node.left, type);
		} else walkPattern(node.left, bindings, isConst);
	}
}
function canNeverBeRef(node, userReactiveImport) {
	if (isCallOf(node, userReactiveImport)) return true;
	switch (node.type) {
		case "UnaryExpression":
		case "BinaryExpression":
		case "ArrayExpression":
		case "ObjectExpression":
		case "FunctionExpression":
		case "ArrowFunctionExpression":
		case "UpdateExpression":
		case "ClassExpression":
		case "TaggedTemplateExpression": return true;
		case "SequenceExpression": return canNeverBeRef(node.expressions[node.expressions.length - 1], userReactiveImport);
		default:
			if (isLiteralNode(node)) return true;
			return false;
	}
}
function mergeSourceMaps(scriptMap, templateMap, templateLineOffset) {
	const generator = new import_source_map.SourceMapGenerator();
	const addMapping = (map, lineOffset = 0) => {
		const consumer = new import_source_map.SourceMapConsumer(map);
		consumer.sources.forEach((sourceFile) => {
			generator._sources.add(sourceFile);
			const sourceContent = consumer.sourceContentFor(sourceFile);
			if (sourceContent != null) generator.setSourceContent(sourceFile, sourceContent);
		});
		consumer.eachMapping((m) => {
			if (m.originalLine == null) return;
			generator.addMapping({
				generated: {
					line: m.generatedLine + lineOffset,
					column: m.generatedColumn
				},
				original: {
					line: m.originalLine,
					column: m.originalColumn
				},
				source: m.source,
				name: m.name
			});
		});
	};
	addMapping(scriptMap);
	addMapping(templateMap, templateLineOffset);
	generator._sourceRoot = scriptMap.sourceRoot;
	generator._file = scriptMap.file;
	return generator.toJSON();
}
//#endregion
//#region packages/compiler-sfc/src/index.ts
init_objectSpread2();
const version = "3.6.0-rc.10";
const parseCache = parseCache$1;
const errorMessages = _objectSpread2(_objectSpread2({}, errorMessages$1), DOMErrorMessages);
const walk = walk$2;
/**
* @deprecated this is preserved to avoid breaking vite-plugin-vue < 5.0
* with reactivityTransform: true. The desired behavior should be silently
* ignoring the option instead of breaking.
*/
const shouldTransformRef = () => false;
//#endregion
var babelParse = import_lib.parse;
export { MagicString, babelParse, compileScript, compileStyle, compileStyleAsync, compileTemplate, errorMessages, extractIdentifiers, extractRuntimeEmits, extractRuntimeProps, generateCodeFrame, inferRuntimeType, invalidateTypeCache, isInDestructureAssignment, isStaticProperty, parse, parseCache, registerTS, resolveTypeElements, rewriteDefault, rewriteDefaultAST, shouldTransformRef, version, walk, walkIdentifiers };