@rolldown-plugin/solid 0.0.0

package/dist/index.mjs

@@ -0,0 +1,3443 @@
+import { parse } from "node:path";
+import { transformAsync } from "@babel/core";
+import { declare, declarePreset } from "@babel/helper-plugin-utils";
+import * as t from "@babel/types";
+import { addComment } from "@babel/types";
+import { addNamed } from "@babel/helper-module-imports";
+import { decode } from "html-entities";
+import * as parse5 from "parse5";
+import assert from "node:assert";
+import * as template from "@babel/template";
+import { visitors } from "@babel/traverse";
+import { OptionValidator } from "@babel/helper-validator-option";
+
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/utils.ts
+const reservedNameSpaces = new Set([
+	"class",
+	"on",
+	"oncapture",
+	"style",
+	"use",
+	"prop",
+	"attr",
+	"bool"
+]);
+const nonSpreadNameSpaces = new Set([
+	"class",
+	"style",
+	"use",
+	"prop",
+	"attr",
+	"bool"
+]);
+function getConfig(path) {
+	return path.hub.file.metadata.config;
+}
+const getRendererConfig = (path, renderer) => {
+	const config = getConfig(path);
+	return config?.renderers?.find((r) => r.name === renderer) ?? config;
+};
+function registerImportMethod(path, name, moduleName) {
+	const imports = path.scope.getProgramParent().data.imports || (path.scope.getProgramParent().data.imports = /* @__PURE__ */ new Map());
+	moduleName = moduleName || getConfig(path).moduleName;
+	if (!imports.has(`${moduleName}:${name}`)) {
+		let id = addNamed(path, name, moduleName, { nameHint: `_$${name}` });
+		imports.set(`${moduleName}:${name}`, id);
+		return id;
+	} else {
+		let iden = imports.get(`${moduleName}:${name}`);
+		return t.cloneNode(iden);
+	}
+}
+function jsxElementNameToString(node) {
+	if (t.isJSXMemberExpression(node)) return `${jsxElementNameToString(node.object)}.${node.property.name}`;
+	if (t.isJSXIdentifier(node) || t.isIdentifier(node)) return node.name;
+	return `${node.namespace.name}:${node.name.name}`;
+}
+function getTagName(tag) {
+	const jsxName = tag.openingElement.name;
+	return jsxElementNameToString(jsxName);
+}
+function isComponent(tagName) {
+	return tagName[0] && tagName[0].toLowerCase() !== tagName[0] || tagName.includes(".") || /[^a-zA-Z]/.test(tagName[0]);
+}
+function hasStaticMarker(object, path) {
+	if (!object) return false;
+	if (object.leadingComments && object.leadingComments[0] && object.leadingComments[0].value.trim() === getConfig(path).staticMarker) return true;
+	if (object.expression) return hasStaticMarker(object.expression, path);
+}
+function isDynamic(path, { checkMember, checkTags, checkCallExpressions = true, native }) {
+	const config = getConfig(path);
+	if (config.generate === "ssr" && native) {
+		checkMember = false;
+		checkCallExpressions = false;
+	}
+	const expr = path.node;
+	if (t.isFunction(expr)) return false;
+	if (expr.leadingComments && expr.leadingComments[0] && expr.leadingComments[0].value.trim() === config.staticMarker) return false;
+	if (checkCallExpressions && (t.isCallExpression(expr) || t.isOptionalCallExpression(expr) || t.isTaggedTemplateExpression(expr))) return true;
+	if (checkMember && t.isMemberExpression(expr)) {
+		const object = path.get("object").node;
+		if (t.isIdentifier(object) && (!expr.computed || !isDynamic(path.get("property"), {
+			checkMember,
+			checkTags,
+			checkCallExpressions,
+			native
+		}))) {
+			const binding = path.scope.getBinding(object.name);
+			if (binding && binding.path.isImportNamespaceSpecifier()) return false;
+		}
+		return true;
+	}
+	if (checkMember && (t.isOptionalMemberExpression(expr) || t.isSpreadElement(expr) || t.isBinaryExpression(expr) && expr.operator === "in")) return true;
+	if (checkTags && (t.isJSXElement(expr) || t.isJSXFragment(expr) && expr.children.length)) return true;
+	let dynamic;
+	path.traverse({
+		Function(p) {
+			if (t.isObjectMethod(p.node) && p.node.computed) dynamic = isDynamic(p.get("key"), {
+				checkMember,
+				checkTags,
+				checkCallExpressions,
+				native
+			});
+			p.skip();
+		},
+		CallExpression(p) {
+			checkCallExpressions && (dynamic = true) && p.stop();
+		},
+		OptionalCallExpression(p) {
+			checkCallExpressions && (dynamic = true) && p.stop();
+		},
+		MemberExpression(p) {
+			checkMember && (dynamic = true) && p.stop();
+		},
+		OptionalMemberExpression(p) {
+			checkMember && (dynamic = true) && p.stop();
+		},
+		SpreadElement(p) {
+			checkMember && (dynamic = true) && p.stop();
+		},
+		BinaryExpression(p) {
+			checkMember && p.node.operator === "in" && (dynamic = true) && p.stop();
+		},
+		JSXElement(p) {
+			checkTags ? (dynamic = true) && p.stop() : p.skip();
+		},
+		JSXFragment(p) {
+			checkTags && p.node.children.length ? (dynamic = true) && p.stop() : p.skip();
+		}
+	});
+	return dynamic;
+}
+function getStaticExpression(path) {
+	const node = path.node;
+	let value, type;
+	return t.isJSXExpressionContainer(node) && t.isJSXElement(path.parent) && !isComponent(getTagName(path.parent)) && !t.isSequenceExpression(node.expression) && (value = path.get("expression").evaluate().value) !== void 0 && ((type = typeof value) === "string" || type === "number") && value;
+}
+function filterChildren(children) {
+	return children.filter(({ node: child }) => !(t.isJSXExpressionContainer(child) && t.isJSXEmptyExpression(child.expression)) && (!t.isJSXText(child) || !/^[\r\n]\s*$/.test(child.extra.raw)));
+}
+function checkLength(children) {
+	let i = 0;
+	children.forEach((path) => {
+		const child = path.node;
+		!(t.isJSXExpressionContainer(child) && t.isJSXEmptyExpression(child.expression)) && (!t.isJSXText(child) || !/^\s*$/.test(child.extra.raw) || /^ *$/.test(child.extra.raw)) && i++;
+	});
+	return i > 1;
+}
+function trimWhitespace(text) {
+	text = text.replace(/\r/g, "");
+	if (/\n/g.test(text)) text = text.split("\n").map((t$1, i) => i ? t$1.replace(/^\s*/g, "") : t$1).filter((s) => !/^\s*$/.test(s)).join(" ");
+	return text.replace(/\s+/g, " ");
+}
+function toEventName(name) {
+	return name.slice(2).toLowerCase();
+}
+function toPropertyName(name) {
+	return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function wrappedByText(list, startIndex) {
+	let index = startIndex, wrapped;
+	while (--index >= 0) {
+		const node = list[index];
+		if (!node) continue;
+		if (node.text) {
+			wrapped = true;
+			break;
+		}
+		if (node.id) return false;
+	}
+	if (!wrapped) return false;
+	index = startIndex;
+	while (++index < list.length) {
+		const node = list[index];
+		if (!node) continue;
+		if (node.text) return true;
+		if (node.id) return false;
+	}
+	return false;
+}
+function transformCondition(path, inline, deep) {
+	const config = getConfig(path);
+	const expr = path.node;
+	const memo = registerImportMethod(path, config.memoWrapper);
+	let dTest, cond, id;
+	if (t.isConditionalExpression(expr) && (isDynamic(path.get("consequent"), {
+		checkTags: true,
+		checkMember: true
+	}) || isDynamic(path.get("alternate"), {
+		checkTags: true,
+		checkMember: true
+	}))) {
+		dTest = isDynamic(path.get("test"), { checkMember: true });
+		if (dTest) {
+			cond = expr.test;
+			if (!t.isBinaryExpression(cond)) cond = t.unaryExpression("!", t.unaryExpression("!", cond, true), true);
+			id = inline ? t.callExpression(memo, [t.arrowFunctionExpression([], cond)]) : path.scope.generateUidIdentifier("_c$");
+			expr.test = t.callExpression(id, []);
+			if (t.isConditionalExpression(expr.consequent) || t.isLogicalExpression(expr.consequent)) expr.consequent = transformCondition(path.get("consequent"), true, true);
+			if (t.isConditionalExpression(expr.alternate) || t.isLogicalExpression(expr.alternate)) expr.alternate = transformCondition(path.get("alternate"), true, true);
+		}
+	} else if (t.isLogicalExpression(expr)) {
+		let nextPath = path;
+		while (nextPath.node.operator !== "&&" && t.isLogicalExpression(nextPath.node.left)) nextPath = nextPath.get("left");
+		nextPath.node.operator === "&&" && isDynamic(nextPath.get("right"), {
+			checkTags: true,
+			checkMember: true
+		}) && (dTest = isDynamic(nextPath.get("left"), { checkMember: true }));
+		if (dTest) {
+			cond = nextPath.node.left;
+			if (!t.isBinaryExpression(cond)) cond = t.unaryExpression("!", t.unaryExpression("!", cond, true), true);
+			id = inline ? t.callExpression(memo, [t.arrowFunctionExpression([], cond)]) : path.scope.generateUidIdentifier("_c$");
+			nextPath.node.left = t.callExpression(id, []);
+		}
+	}
+	if (dTest && !inline) {
+		const statements = [t.variableDeclaration("var", [t.variableDeclarator(id, config.memoWrapper ? t.callExpression(memo, [t.arrowFunctionExpression([], cond)]) : t.arrowFunctionExpression([], cond))]), t.arrowFunctionExpression([], expr)];
+		return deep ? t.callExpression(t.arrowFunctionExpression([], t.blockStatement([statements[0], t.returnStatement(statements[1])])), []) : statements;
+	}
+	return deep ? expr : t.arrowFunctionExpression([], expr);
+}
+function escapeHTML(s, attr) {
+	if (typeof s !== "string") return s;
+	const delim = attr ? "\"" : "<";
+	const escDelim = attr ? "&quot;" : "&lt;";
+	let iDelim = s.indexOf(delim);
+	let iAmp = s.indexOf("&");
+	if (iDelim < 0 && iAmp < 0) return s;
+	let left = 0, out = "";
+	while (iDelim >= 0 && iAmp >= 0) if (iDelim < iAmp) {
+		if (left < iDelim) out += s.substring(left, iDelim);
+		out += escDelim;
+		left = iDelim + 1;
+		iDelim = s.indexOf(delim, left);
+	} else {
+		if (left < iAmp) out += s.substring(left, iAmp);
+		out += "&amp;";
+		left = iAmp + 1;
+		iAmp = s.indexOf("&", left);
+	}
+	if (iDelim >= 0) do {
+		if (left < iDelim) out += s.substring(left, iDelim);
+		out += escDelim;
+		left = iDelim + 1;
+		iDelim = s.indexOf(delim, left);
+	} while (iDelim >= 0);
+	else while (iAmp >= 0) {
+		if (left < iAmp) out += s.substring(left, iAmp);
+		out += "&amp;";
+		left = iAmp + 1;
+		iAmp = s.indexOf("&", left);
+	}
+	return left < s.length ? out + s.substring(left) : out;
+}
+function convertJSXIdentifier(node) {
+	if (t.isJSXIdentifier(node)) if (t.isValidIdentifier(node.name)) node.type = "Identifier";
+	else return t.stringLiteral(node.name);
+	else if (t.isJSXMemberExpression(node)) return t.memberExpression(convertJSXIdentifier(node.object), convertJSXIdentifier(node.property));
+	else if (t.isJSXNamespacedName(node)) return t.stringLiteral(`${node.namespace.name}:${node.name.name}`);
+	return node;
+}
+function canNativeSpread(key, { checkNameSpaces } = {}) {
+	if (checkNameSpaces && key.includes(":") && nonSpreadNameSpaces.has(key.split(":")[0])) return false;
+	if (key === "ref") return false;
+	return true;
+}
+const chars = "etaoinshrdlucwmfygpbTAOISWCBvkxjqzPHFMDRELNGUKVYJQZX_$";
+const base = 54;
+function getNumberedId(num) {
+	let out = "";
+	do {
+		const digit = num % base;
+		num = Math.floor(num / base);
+		out = chars[digit] + out;
+	} while (num !== 0);
+	return out;
+}
+function escapeStringForTemplate(str) {
+	return str.replace(/[{\\`\n\t\b\f\v\r\u2028\u2029]/g, (ch) => templateEscapes.get(ch));
+}
+const templateEscapes = new Map([
+	["{", "\\{"],
+	["`", "\\`"],
+	["\\", "\\\\"],
+	["\n", "\\n"],
+	["	", "\\t"],
+	["\b", "\\b"],
+	["\f", "\\f"],
+	["\v", "\\v"],
+	["\r", "\\r"],
+	["\u2028", "\\u2028"],
+	["\u2029", "\\u2029"]
+]);
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/dom-expressions/constants.js
+const booleans = [
+	"allowfullscreen",
+	"async",
+	"alpha",
+	"autofocus",
+	"autoplay",
+	"checked",
+	"controls",
+	"default",
+	"disabled",
+	"formnovalidate",
+	"hidden",
+	"indeterminate",
+	"inert",
+	"ismap",
+	"loop",
+	"multiple",
+	"muted",
+	"nomodule",
+	"novalidate",
+	"open",
+	"playsinline",
+	"readonly",
+	"required",
+	"reversed",
+	"seamless",
+	"selected",
+	"adauctionheaders",
+	"browsingtopics",
+	"credentialless",
+	"defaultchecked",
+	"defaultmuted",
+	"defaultselected",
+	"defer",
+	"disablepictureinpicture",
+	"disableremoteplayback",
+	"preservespitch",
+	"shadowrootclonable",
+	"shadowrootcustomelementregistry",
+	"shadowrootdelegatesfocus",
+	"shadowrootserializable",
+	"sharedstoragewritable"
+];
+const BooleanAttributes = /* @__PURE__ */ new Set(booleans);
+const Properties = /* @__PURE__ */ new Set([
+	"className",
+	"value",
+	"readOnly",
+	"noValidate",
+	"formNoValidate",
+	"isMap",
+	"noModule",
+	"playsInline",
+	"adAuctionHeaders",
+	"allowFullscreen",
+	"browsingTopics",
+	"defaultChecked",
+	"defaultMuted",
+	"defaultSelected",
+	"disablePictureInPicture",
+	"disableRemotePlayback",
+	"preservesPitch",
+	"shadowRootClonable",
+	"shadowRootCustomElementRegistry",
+	"shadowRootDelegatesFocus",
+	"shadowRootSerializable",
+	"sharedStorageWritable",
+	...booleans
+]);
+const ChildProperties = /* @__PURE__ */ new Set([
+	"innerHTML",
+	"textContent",
+	"innerText",
+	"children"
+]);
+const Aliases = /* @__PURE__ */ Object.assign(Object.create(null), {
+	className: "class",
+	htmlFor: "for"
+});
+const PropAliases = /* @__PURE__ */ Object.assign(Object.create(null), {
+	class: "className",
+	novalidate: {
+		$: "noValidate",
+		FORM: 1
+	},
+	formnovalidate: {
+		$: "formNoValidate",
+		BUTTON: 1,
+		INPUT: 1
+	},
+	ismap: {
+		$: "isMap",
+		IMG: 1
+	},
+	nomodule: {
+		$: "noModule",
+		SCRIPT: 1
+	},
+	playsinline: {
+		$: "playsInline",
+		VIDEO: 1
+	},
+	readonly: {
+		$: "readOnly",
+		INPUT: 1,
+		TEXTAREA: 1
+	},
+	adauctionheaders: {
+		$: "adAuctionHeaders",
+		IFRAME: 1
+	},
+	allowfullscreen: {
+		$: "allowFullscreen",
+		IFRAME: 1
+	},
+	browsingtopics: {
+		$: "browsingTopics",
+		IMG: 1
+	},
+	defaultchecked: {
+		$: "defaultChecked",
+		INPUT: 1
+	},
+	defaultmuted: {
+		$: "defaultMuted",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	defaultselected: {
+		$: "defaultSelected",
+		OPTION: 1
+	},
+	disablepictureinpicture: {
+		$: "disablePictureInPicture",
+		VIDEO: 1
+	},
+	disableremoteplayback: {
+		$: "disableRemotePlayback",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	preservespitch: {
+		$: "preservesPitch",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	shadowrootclonable: {
+		$: "shadowRootClonable",
+		TEMPLATE: 1
+	},
+	shadowrootdelegatesfocus: {
+		$: "shadowRootDelegatesFocus",
+		TEMPLATE: 1
+	},
+	shadowrootserializable: {
+		$: "shadowRootSerializable",
+		TEMPLATE: 1
+	},
+	sharedstoragewritable: {
+		$: "sharedStorageWritable",
+		IFRAME: 1,
+		IMG: 1
+	}
+});
+function getPropAlias(prop, tagName) {
+	const a = PropAliases[prop];
+	return typeof a === "object" ? a[tagName] ? a["$"] : void 0 : a;
+}
+const DelegatedEvents = /* @__PURE__ */ new Set([
+	"beforeinput",
+	"click",
+	"dblclick",
+	"contextmenu",
+	"focusin",
+	"focusout",
+	"input",
+	"keydown",
+	"keyup",
+	"mousedown",
+	"mousemove",
+	"mouseout",
+	"mouseover",
+	"mouseup",
+	"pointerdown",
+	"pointermove",
+	"pointerout",
+	"pointerover",
+	"pointerup",
+	"touchend",
+	"touchmove",
+	"touchstart"
+]);
+const SVGElements = /* @__PURE__ */ new Set([
+	"altGlyph",
+	"altGlyphDef",
+	"altGlyphItem",
+	"animate",
+	"animateColor",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"clipPath",
+	"color-profile",
+	"cursor",
+	"defs",
+	"desc",
+	"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",
+	"font",
+	"font-face",
+	"font-face-format",
+	"font-face-name",
+	"font-face-src",
+	"font-face-uri",
+	"foreignObject",
+	"g",
+	"glyph",
+	"glyphRef",
+	"hkern",
+	"image",
+	"line",
+	"linearGradient",
+	"marker",
+	"mask",
+	"metadata",
+	"missing-glyph",
+	"mpath",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialGradient",
+	"rect",
+	"set",
+	"stop",
+	"svg",
+	"switch",
+	"symbol",
+	"text",
+	"textPath",
+	"tref",
+	"tspan",
+	"use",
+	"view",
+	"vkern"
+]);
+const SVGNamespace = {
+	xlink: "http://www.w3.org/1999/xlink",
+	xml: "http://www.w3.org/XML/1998/namespace"
+};
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/VoidElements.ts
+const voidElements = [
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"keygen",
+	"link",
+	"menuitem",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+];
+var VoidElements_default = voidElements;
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/ssr/template.ts
+function createTemplate$2(path, result) {
+	if (!result.template) return result.exprs[0];
+	let template$1, id;
+	if (!Array.isArray(result.template)) template$1 = t.stringLiteral(result.template);
+	else if (result.template.length === 1) template$1 = t.stringLiteral(result.template[0]);
+	else {
+		const strings = result.template.map((tmpl) => t.stringLiteral(tmpl));
+		template$1 = t.arrayExpression(strings);
+	}
+	const templates = path.scope.getProgramParent().data.templates || (path.scope.getProgramParent().data.templates = []);
+	const found = templates.find((tmp) => {
+		if (t.isArrayExpression(tmp.template) && t.isArrayExpression(template$1)) return tmp.template.elements.every((el, i) => template$1.elements[i] && el.value === template$1.elements[i].value);
+		return tmp.template.value === template$1.value;
+	});
+	if (!found) {
+		id = path.scope.generateUidIdentifier("tmpl$");
+		templates.push({
+			id,
+			template: template$1,
+			templateWithClosingTags: template$1,
+			renderer: "ssr"
+		});
+	} else id = found.id;
+	if (result.wontEscape) {
+		if (!Array.isArray(result.template) || result.template.length === 1) return id;
+		else if (Array.isArray(result.template) && result.template.length === 2 && result.templateValues[0].type === "CallExpression" && result.templateValues[0].callee.name === "_$ssrHydrationKey") return t.binaryExpression("+", t.binaryExpression("+", t.memberExpression(id, t.numericLiteral(0), true), result.templateValues[0]), t.memberExpression(id, t.numericLiteral(1), true));
+	}
+	return t.callExpression(registerImportMethod(path, "ssr"), Array.isArray(result.template) && result.template.length > 1 ? [id, ...result.templateValues] : [id]);
+}
+function appendTemplates$1(path, templates) {
+	const declarators = templates.map((template$1) => {
+		return t.variableDeclarator(template$1.id, template$1.template);
+	});
+	path.node.body.unshift(t.variableDeclaration("var", declarators));
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/ssr/element.ts
+function appendToTemplate(template$1, value) {
+	let array;
+	if (Array.isArray(value)) [value, ...array] = value;
+	template$1[template$1.length - 1] += value;
+	if (array && array.length) template$1.push.apply(template$1, array);
+}
+function transformElement$3(path, info) {
+	const config = getConfig(path);
+	const tagName = getTagName(path.node);
+	if (tagName === "script" || tagName === "style") path.doNotEscape = true;
+	if (path.node.openingElement.attributes.some((a) => t.isJSXSpreadAttribute(a))) return createElement(path, {
+		...info,
+		...config
+	});
+	const voidTag = VoidElements_default.indexOf(tagName) > -1, results = {
+		template: [`<${tagName}`],
+		templateValues: [],
+		declarations: [],
+		exprs: [],
+		dynamics: [],
+		tagName,
+		wontEscape: path.node.wontEscape,
+		renderer: "ssr"
+	};
+	if (info.topLevel && config.hydratable) {
+		if (tagName === "head") {
+			registerImportMethod(path, "NoHydration");
+			registerImportMethod(path, "createComponent");
+			const child = transformElement$3(path, {
+				...info,
+				topLevel: false
+			});
+			results.template = "";
+			results.templateWithClosingTags = "";
+			results.exprs.push(t.callExpression(t.identifier("_$createComponent"), [t.identifier("_$NoHydration"), t.objectExpression([t.objectMethod("get", t.identifier("children"), [], t.blockStatement([t.returnStatement(createTemplate$2(path, child))]))])]));
+			return results;
+		}
+		results.template.push("");
+		results.templateValues.push(t.callExpression(registerImportMethod(path, "ssrHydrationKey"), []));
+	}
+	transformAttributes$2(path, results, {
+		...config,
+		...info
+	});
+	appendToTemplate(results.template, ">");
+	if (!voidTag) {
+		transformChildren$2(path, results, {
+			...config,
+			...info
+		});
+		appendToTemplate(results.template, `</${tagName}>`);
+	}
+	return results;
+}
+function toAttribute(key, isSVG) {
+	key = Aliases[key] || key;
+	!isSVG && (key = key.toLowerCase());
+	return key;
+}
+function setAttr$2(attribute, results, name, value, isSVG) {
+	let parts;
+	if ((parts = name.split(":")) && parts[1] && reservedNameSpaces.has(parts[0])) {
+		name = parts[1];
+		parts[0];
+	}
+	name = toAttribute(name, isSVG);
+	const attr = t.callExpression(registerImportMethod(attribute, "ssrAttribute"), [
+		t.stringLiteral(name),
+		value,
+		t.booleanLiteral(false)
+	]);
+	if (results.template[results.template.length - 1].length) {
+		results.template.push("");
+		results.templateValues.push(attr);
+	} else {
+		const last = results.templateValues.length - 1;
+		results.templateValues[last] = t.binaryExpression("+", results.templateValues[last], attr);
+	}
+}
+function escapeExpression(path, expression, attr, escapeLiterals) {
+	if (t.isStringLiteral(expression) || t.isNumericLiteral(expression) || t.isTemplateLiteral(expression) && expression.expressions.length === 0) {
+		if (escapeLiterals) {
+			if (t.isStringLiteral(expression)) return t.stringLiteral(escapeHTML(expression.value, attr));
+			else if (t.isTemplateLiteral(expression)) return t.stringLiteral(escapeHTML(expression.quasis[0].value.raw, attr));
+		}
+		return expression;
+	} else if (t.isFunction(expression)) {
+		if (t.isBlockStatement(expression.body)) expression.body.body = expression.body.body.map((e) => {
+			if (t.isReturnStatement(e)) e.argument = escapeExpression(path, e.argument, attr, escapeLiterals);
+			return e;
+		});
+		else expression.body = escapeExpression(path, expression.body, attr, escapeLiterals);
+		return expression;
+	} else if (t.isTemplateLiteral(expression)) {
+		expression.expressions = expression.expressions.map((e) => escapeExpression(path, e, attr, escapeLiterals));
+		return expression;
+	} else if (t.isUnaryExpression(expression)) return expression;
+	else if (t.isBinaryExpression(expression)) {
+		expression.left = escapeExpression(path, expression.left, attr, escapeLiterals);
+		expression.right = escapeExpression(path, expression.right, attr, escapeLiterals);
+		return expression;
+	} else if (t.isConditionalExpression(expression)) {
+		expression.consequent = escapeExpression(path, expression.consequent, attr, escapeLiterals);
+		expression.alternate = escapeExpression(path, expression.alternate, attr, escapeLiterals);
+		return expression;
+	} else if (t.isLogicalExpression(expression)) {
+		expression.right = escapeExpression(path, expression.right, attr, escapeLiterals);
+		if (expression.operator !== "&&") expression.left = escapeExpression(path, expression.left, attr, escapeLiterals);
+		return expression;
+	} else if (t.isCallExpression(expression) && t.isFunction(expression.callee)) {
+		if (t.isBlockStatement(expression.callee.body)) expression.callee.body.body = expression.callee.body.body.map((e) => {
+			if (t.isReturnStatement(e)) e.argument = escapeExpression(path, e.argument, attr, escapeLiterals);
+			return e;
+		});
+		else expression.callee.body = escapeExpression(path, expression.callee.body, attr, escapeLiterals);
+		return expression;
+	} else if (t.isJSXElement(expression) && !isComponent(getTagName(expression))) {
+		expression.wontEscape = true;
+		return expression;
+	}
+	return t.callExpression(registerImportMethod(path, "escape"), [expression].concat(attr ? [t.booleanLiteral(true)] : []));
+}
+function transformToObject(attrName, attributes, selectedAttributes) {
+	const properties = [];
+	const existingAttribute = attributes.find((a) => a.node.name.name === attrName);
+	for (let i = 0; i < selectedAttributes.length; i++) {
+		const attr = selectedAttributes[i].node;
+		const computed = !t.isValidIdentifier(attr.name.name.name);
+		if (!computed) attr.name.name.type = "Identifier";
+		properties.push(t.objectProperty(computed ? t.stringLiteral(attr.name.name.name) : attr.name.name, t.isJSXExpressionContainer(attr.value) ? attr.value.expression : attr.value));
+		(existingAttribute || i) && attributes.splice(selectedAttributes[i].key, 1);
+	}
+	if (existingAttribute && t.isJSXExpressionContainer(existingAttribute.node.value) && t.isObjectExpression(existingAttribute.node.value.expression)) existingAttribute.node.value.expression.properties.push(...properties);
+	else selectedAttributes[0].node = t.jsxAttribute(t.jsxIdentifier(attrName), t.jsxExpressionContainer(t.objectExpression(properties)));
+}
+function normalizeAttributes(path) {
+	const attributes = path.get("openingElement").get("attributes"), styleAttributes = attributes.filter((a) => t.isJSXNamespacedName(a.node.name) && a.node.name.namespace.name === "style"), classNamespaceAttributes = attributes.filter((a) => t.isJSXNamespacedName(a.node.name) && a.node.name.namespace.name === "class");
+	if (classNamespaceAttributes.length) transformToObject("classList", attributes, classNamespaceAttributes);
+	const classAttributes = attributes.filter((a) => a.node.name && (a.node.name.name === "class" || a.node.name.name === "className" || a.node.name.name === "classList"));
+	if (classAttributes.length > 1) {
+		const first = classAttributes[0].node, values = [], quasis = [t.templateElement({ raw: "" })];
+		for (let i = 0; i < classAttributes.length; i++) {
+			const attr = classAttributes[i].node, isLast = i === classAttributes.length - 1;
+			if (!t.isJSXExpressionContainer(attr.value)) {
+				const prev = quasis.pop();
+				quasis.push(t.templateElement({ raw: (prev ? prev.value.raw : "") + `${attr.value.value}` + (isLast ? "" : " ") }));
+			} else {
+				let expr = attr.value.expression;
+				if (attr.name.name === "classList") {
+					if (t.isObjectExpression(expr) && !expr.properties.some((p) => t.isSpreadElement(p))) {
+						transformClasslistObject(path, expr, values, quasis);
+						if (!isLast) quasis[quasis.length - 1].value.raw += " ";
+						i && attributes.splice(attributes.indexOf(classAttributes[i]), 1);
+						continue;
+					}
+					expr = t.callExpression(registerImportMethod(path, "ssrClassList"), [expr]);
+				}
+				values.push(t.logicalExpression("||", expr, t.stringLiteral("")));
+				quasis.push(t.templateElement({ raw: isLast ? "" : " " }));
+			}
+			i && attributes.splice(attributes.indexOf(classAttributes[i]), 1);
+		}
+		first.name = t.jsxIdentifier("class");
+		first.value = t.jsxExpressionContainer(t.templateLiteral(quasis, values));
+	}
+	if (styleAttributes.length) transformToObject("style", attributes, styleAttributes);
+	return attributes;
+}
+function transformAttributes$2(path, results, info) {
+	const tagName = getTagName(path.node), isSVG = SVGElements.has(tagName), hasChildren = path.node.children.length > 0, attributes = normalizeAttributes(path);
+	let children;
+	attributes.forEach((attribute) => {
+		const node = attribute.node;
+		let value = node.value, key = t.isJSXNamespacedName(node.name) ? `${node.name.namespace.name}:${node.name.name.name}` : node.name.name, reservedNameSpace = t.isJSXNamespacedName(node.name) && reservedNameSpaces.has(node.name.namespace.name);
+		if ((t.isJSXNamespacedName(node.name) && reservedNameSpace || ChildProperties.has(key)) && !t.isJSXExpressionContainer(value)) node.value = value = t.jsxExpressionContainer(value || t.jsxEmptyExpression());
+		if (t.isJSXExpressionContainer(value) && (reservedNameSpace || ChildProperties.has(key) || !(t.isStringLiteral(value.expression) || t.isNumericLiteral(value.expression) || t.isBooleanLiteral(value.expression)))) if (key === "ref" || key.startsWith("use:") || key.startsWith("prop:") || key.startsWith("on")) return;
+		else if (ChildProperties.has(key)) {
+			if (info.hydratable && key === "textContent" && value && value.expression) value.expression = t.logicalExpression("||", value.expression, t.stringLiteral(" "));
+			if (key === "innerHTML") path.doNotEscape = true;
+			children = value;
+		} else {
+			let doEscape = true;
+			if (key.startsWith("attr:")) key = key.replace("attr:", "");
+			if (BooleanAttributes.has(key)) {
+				results.template.push("");
+				const fn = t.callExpression(registerImportMethod(attribute, "ssrAttribute"), [
+					t.stringLiteral(key),
+					value.expression,
+					t.booleanLiteral(true)
+				]);
+				results.templateValues.push(fn);
+				return;
+			}
+			if (key === "style") {
+				if (t.isJSXExpressionContainer(value) && t.isObjectExpression(value.expression) && !value.expression.properties.some((p) => t.isSpreadElement(p))) {
+					const props = value.expression.properties.map((p, i) => t.callExpression(registerImportMethod(path, "ssrStyleProperty"), [t.stringLiteral((i ? ";" : "") + (t.isIdentifier(p.key) ? p.key.name : p.key.value) + ":"), escapeExpression(path, p.value, true, true)]));
+					let res = props[0];
+					for (let i = 1; i < props.length; i++) res = t.binaryExpression("+", res, props[i]);
+					value.expression = res;
+				} else value.expression = t.callExpression(registerImportMethod(path, "ssrStyle"), [value.expression]);
+				doEscape = false;
+			}
+			if (key === "classList") {
+				if (t.isObjectExpression(value.expression) && !value.expression.properties.some((p) => t.isSpreadElement(p))) {
+					const values = [], quasis = [t.templateElement({ raw: "" })];
+					transformClasslistObject(path, value.expression, values, quasis);
+					if (!values.length) value.expression = t.stringLiteral(quasis[0].value.raw);
+					else if (values.length === 1 && !quasis[0].value.raw && !quasis[1].value.raw) value.expression = values[0];
+					else value.expression = t.templateLiteral(quasis, values);
+				} else value.expression = t.callExpression(registerImportMethod(path, "ssrClassList"), [value.expression]);
+				key = "class";
+				doEscape = false;
+			}
+			if (doEscape) value.expression = escapeExpression(path, value.expression, true);
+			if (!doEscape || t.isLiteral(value.expression)) {
+				key = toAttribute(key, isSVG);
+				appendToTemplate(results.template, ` ${key}="`);
+				results.template.push(`"`);
+				results.templateValues.push(value.expression);
+			} else setAttr$2(attribute, results, key, value.expression, isSVG);
+		}
+		else {
+			if (key === "$ServerOnly") return;
+			if (t.isJSXExpressionContainer(value)) value = value.expression;
+			key = toAttribute(key, isSVG);
+			const isBoolean = BooleanAttributes.has(key);
+			if (isBoolean && value && value.value !== "" && !value.value) return;
+			appendToTemplate(results.template, ` ${key}`);
+			if (!value) return;
+			let text = isBoolean ? "" : value.value;
+			if (key === "style" || key === "class") {
+				text = trimWhitespace(String(text));
+				if (key === "style") text = text.replace(/; /g, ";").replace(/: /g, ":");
+			}
+			appendToTemplate(results.template, String(text) === "" ? `` : `="${escapeHTML(text, true)}"`);
+		}
+	});
+	if (!hasChildren && children) path.node.children.push(children);
+}
+function transformClasslistObject(path, expr, values, quasis) {
+	expr.properties.forEach((prop, i) => {
+		const isLast = expr.properties.length - 1 === i;
+		let key = prop.key;
+		if (t.isIdentifier(prop.key) && !prop.computed) key = t.stringLiteral(key.name);
+		else if (prop.computed) key = t.callExpression(registerImportMethod(path, "escape"), [prop.key, t.booleanLiteral(true)]);
+		else key = t.stringLiteral(escapeHTML(prop.key.value));
+		if (t.isBooleanLiteral(prop.value)) {
+			if (prop.value.value === true) if (!prop.computed) {
+				const prev = quasis.pop();
+				quasis.push(t.templateElement({ raw: (prev ? prev.value.raw : "") + (i ? " " : "") + `${key.value}` + (isLast ? "" : " ") }));
+			} else {
+				values.push(key);
+				quasis.push(t.templateElement({ raw: isLast ? "" : " " }));
+			}
+		} else {
+			values.push(t.conditionalExpression(prop.value, key, t.stringLiteral("")));
+			quasis.push(t.templateElement({ raw: isLast ? "" : " " }));
+		}
+	});
+}
+function transformChildren$2(path, results, { hydratable }) {
+	const doNotEscape = path.doNotEscape;
+	const filteredChildren = filterChildren(path.get("children"));
+	const multi = checkLength(filteredChildren), markers = hydratable && multi;
+	filteredChildren.forEach((node) => {
+		if (t.isJSXElement(node.node) && getTagName(node.node) === "head") {
+			const child$1 = transformNode(node, {
+				doNotEscape,
+				hydratable: false
+			});
+			registerImportMethod(path, "NoHydration");
+			registerImportMethod(path, "createComponent");
+			results.template.push("");
+			results.templateValues.push(t.callExpression(t.identifier("_$createComponent"), [t.identifier("_$NoHydration"), t.objectExpression([t.objectMethod("get", t.identifier("children"), [], t.blockStatement([t.returnStatement(createTemplate$2(path, child$1))]))])]));
+			return;
+		}
+		const child = transformNode(node, { doNotEscape });
+		if (!child) return;
+		appendToTemplate(results.template, child.template);
+		results.templateValues.push.apply(results.templateValues, child.templateValues || []);
+		if (child.exprs.length) {
+			if (!doNotEscape && !child.spreadElement) child.exprs[0] = escapeExpression(path, child.exprs[0]);
+			if (markers && !child.spreadElement) {
+				appendToTemplate(results.template, `<!--$-->`);
+				results.template.push("");
+				results.templateValues.push(child.exprs[0]);
+				appendToTemplate(results.template, `<!--/-->`);
+			} else {
+				results.template.push("");
+				results.templateValues.push(child.exprs[0]);
+			}
+		}
+	});
+}
+function createElement(path, { topLevel, hydratable }) {
+	const tagName = getTagName(path.node), config = getConfig(path), attributes = normalizeAttributes(path), doNotEscape = path.doNotEscape;
+	const filteredChildren = filterChildren(path.get("children")), multi = checkLength(filteredChildren), markers = hydratable && multi, childNodes = filteredChildren.reduce((memo, path$1) => {
+		if (t.isJSXText(path$1.node)) {
+			const v$1 = decode(trimWhitespace(path$1.node.extra.raw));
+			if (v$1.length) memo.push(t.stringLiteral(v$1));
+		} else {
+			const child = transformNode(path$1);
+			if (markers && child.exprs.length && !child.spreadElement) memo.push(t.stringLiteral("<!--$-->"));
+			if (child.exprs.length && !doNotEscape && !child.spreadElement) child.exprs[0] = escapeExpression(path$1, child.exprs[0]);
+			memo.push(getCreateTemplate(config, path$1, child)(path$1, child, true));
+			if (markers && child.exprs.length && !child.spreadElement) memo.push(t.stringLiteral("<!--/-->"));
+		}
+		return memo;
+	}, []);
+	let props;
+	if (attributes.length === 1) props = [attributes[0].node.argument];
+	else {
+		props = [];
+		let runningObject = [], dynamicSpread = false, hasChildren = path.node.children.length > 0;
+		attributes.forEach((attribute) => {
+			const node = attribute.node;
+			if (t.isJSXSpreadAttribute(node)) {
+				if (runningObject.length) {
+					props.push(t.objectExpression(runningObject));
+					runningObject = [];
+				}
+				props.push(isDynamic(attribute.get("argument"), { checkMember: true }) && (dynamicSpread = true) ? t.isCallExpression(node.argument) && !node.argument.arguments.length && !t.isCallExpression(node.argument.callee) && !t.isMemberExpression(node.argument.callee) ? node.argument.callee : t.arrowFunctionExpression([], node.argument) : node.argument);
+			} else {
+				const value = node.value || t.booleanLiteral(true), id = convertJSXIdentifier(node.name), key = t.isJSXNamespacedName(node.name) ? `${node.name.namespace.name}:${node.name.name.name}` : node.name.name;
+				if (hasChildren && key === "children") return;
+				if (key === "ref" || key.startsWith("use:") || key.startsWith("prop:") || key.startsWith("on")) return;
+				if (t.isJSXExpressionContainer(value)) if (isDynamic(attribute.get("value").get("expression"), {
+					checkMember: true,
+					checkTags: true
+				})) {
+					let expr = t.arrowFunctionExpression([], value.expression);
+					runningObject.push(t.objectMethod("get", id, [], t.blockStatement([t.returnStatement(expr.body)]), !t.isValidIdentifier(key)));
+				} else runningObject.push(t.objectProperty(id, value.expression));
+				else runningObject.push(t.objectProperty(id, value));
+			}
+		});
+		if (runningObject.length || !props.length) props.push(t.objectExpression(runningObject));
+		if (props.length > 1 || dynamicSpread) props = [t.callExpression(registerImportMethod(path, "mergeProps"), props)];
+	}
+	return {
+		exprs: [t.callExpression(registerImportMethod(path, "ssrElement"), [
+			t.stringLiteral(tagName),
+			props[0],
+			childNodes.length ? hydratable ? t.arrowFunctionExpression([], childNodes.length === 1 ? childNodes[0] : t.arrayExpression(childNodes)) : childNodes.length === 1 ? childNodes[0] : t.arrayExpression(childNodes) : t.identifier("undefined"),
+			t.booleanLiteral(Boolean(topLevel && config.hydratable))
+		])],
+		template: "",
+		spreadElement: true
+	};
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/universal/element.ts
+function transformElement$2(path, info) {
+	let tagName = getTagName(path.node), results = {
+		id: path.scope.generateUidIdentifier("el$"),
+		declarations: [],
+		exprs: [],
+		dynamics: [],
+		postExprs: [],
+		tagName,
+		renderer: "universal"
+	};
+	results.declarations.push(t.variableDeclarator(results.id, t.callExpression(registerImportMethod(path, "createElement", getRendererConfig(path, "universal").moduleName), [t.stringLiteral(tagName)])));
+	transformAttributes$1(path, results);
+	transformChildren$1(path, results);
+	return results;
+}
+function transformAttributes$1(path, results) {
+	let children, spreadExpr;
+	let attributes = path.get("openingElement").get("attributes");
+	const elem = results.id, hasChildren = path.node.children.length > 0, config = getConfig(path);
+	if (attributes.some((attribute) => t.isJSXSpreadAttribute(attribute.node))) {
+		[attributes, spreadExpr] = processSpreads$1(path, attributes, {
+			elem,
+			hasChildren,
+			wrapConditionals: config.wrapConditionals
+		});
+		path.get("openingElement").set("attributes", attributes.map((a) => a.node));
+	}
+	path.get("openingElement").get("attributes").forEach((attribute) => {
+		const node = attribute.node;
+		let value = node.value, key = t.isJSXNamespacedName(node.name) ? `${node.name.namespace.name}:${node.name.name.name}` : node.name.name, reservedNameSpace = t.isJSXNamespacedName(node.name) && node.name.namespace.name === "use";
+		if (t.isJSXNamespacedName(node.name) && reservedNameSpace && !t.isJSXExpressionContainer(value)) node.value = value = t.jsxExpressionContainer(value || t.jsxEmptyExpression());
+		if (t.isJSXExpressionContainer(value)) if (key === "ref") {
+			while (t.isTSNonNullExpression(value.expression) || t.isTSAsExpression(value.expression)) value.expression = value.expression.expression;
+			let binding, isConstant = t.isIdentifier(value.expression) && (binding = path.scope.getBinding(value.expression.name)) && (binding.kind === "const" || binding.kind === "module");
+			if (!isConstant && t.isLVal(value.expression)) {
+				const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+				results.exprs.unshift(t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "universal").moduleName), [refIdentifier, elem]), t.assignmentExpression("=", value.expression, elem))));
+			} else if (isConstant || t.isFunction(value.expression)) results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "universal").moduleName), [value.expression, elem])));
+			else {
+				const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+				results.exprs.unshift(t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.logicalExpression("&&", t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "universal").moduleName), [refIdentifier, elem]))));
+			}
+		} else if (key.startsWith("use:")) {
+			node.name.name.type = "Identifier";
+			results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "universal").moduleName), [
+				node.name.name,
+				elem,
+				t.arrowFunctionExpression([], t.isJSXEmptyExpression(value.expression) ? t.booleanLiteral(true) : value.expression)
+			])));
+		} else if (key === "children") children = value;
+		else if (config.effectWrapper && isDynamic(attribute.get("value").get("expression"), { checkMember: true })) results.dynamics.push({
+			elem,
+			key,
+			value: value.expression
+		});
+		else results.exprs.push(t.expressionStatement(setAttr$1(attribute, elem, key, value.expression)));
+		else results.exprs.push(t.expressionStatement(setAttr$1(attribute, elem, key, value)));
+	});
+	if (spreadExpr) results.exprs.push(spreadExpr);
+	if (!hasChildren && children) path.node.children.push(children);
+}
+function setAttr$1(path, elem, name, value, { prevId } = {}) {
+	if (!value) value = t.booleanLiteral(true);
+	return t.callExpression(registerImportMethod(path, "setProp", getRendererConfig(path, "universal").moduleName), prevId ? [
+		elem,
+		t.stringLiteral(name),
+		value,
+		prevId
+	] : [
+		elem,
+		t.stringLiteral(name),
+		value
+	]);
+}
+function transformChildren$1(path, results) {
+	const filteredChildren = filterChildren(path.get("children")), multi = checkLength(filteredChildren), childNodes = filteredChildren.map(transformNode).reduce((memo, child) => {
+		if (!child) return memo;
+		const i = memo.length;
+		if (child.text && i && memo[i - 1].text) {
+			memo[i - 1].template += child.template;
+			memo[i - 1].templateWithClosingTags += child.templateWithClosingTags || child.template;
+		} else memo.push(child);
+		return memo;
+	}, []);
+	const appends = [];
+	childNodes.forEach((child, index) => {
+		if (!child) return;
+		if (child.tagName && child.renderer !== "universal") throw new Error(`<${child.tagName}> is not supported in <${getTagName(path.node)}>.
+        Wrap the usage with a component that would render this element, eg. Canvas`);
+		if (child.id) {
+			let insertNode = registerImportMethod(path, "insertNode", getRendererConfig(path, "universal").moduleName);
+			let insert = child.id;
+			if (child.text) {
+				let createTextNode = registerImportMethod(path, "createTextNode", getRendererConfig(path, "universal").moduleName);
+				if (multi) results.declarations.push(t.variableDeclarator(child.id, t.callExpression(createTextNode, [t.templateLiteral([t.templateElement({ raw: escapeStringForTemplate(child.template) })], [])])));
+				else insert = t.callExpression(createTextNode, [t.templateLiteral([t.templateElement({ raw: escapeStringForTemplate(child.template) })], [])]);
+			}
+			appends.push(t.expressionStatement(t.callExpression(insertNode, [results.id, insert])));
+			results.declarations.push(...child.declarations);
+			results.exprs.push(...child.exprs);
+			results.dynamics.push(...child.dynamics);
+		} else if (child.exprs.length) {
+			let insert = registerImportMethod(path, "insert", getRendererConfig(path, "universal").moduleName);
+			if (multi) results.exprs.push(t.expressionStatement(t.callExpression(insert, [
+				results.id,
+				child.exprs[0],
+				nextChild$1(childNodes, index) || t.nullLiteral()
+			])));
+			else results.exprs.push(t.expressionStatement(t.callExpression(insert, [results.id, child.exprs[0]])));
+		}
+	});
+	results.exprs.unshift(...appends);
+}
+function nextChild$1(children, index) {
+	return children[index + 1] && (children[index + 1].id || nextChild$1(children, index + 1));
+}
+function processSpreads$1(path, attributes, { elem, hasChildren, wrapConditionals }) {
+	const filteredAttributes = [];
+	const spreadArgs = [];
+	let runningObject = [];
+	let dynamicSpread = false;
+	let firstSpread = false;
+	attributes.forEach((attribute) => {
+		const node = attribute.node;
+		const key = !t.isJSXSpreadAttribute(node) && (t.isJSXNamespacedName(node.name) ? `${node.name.namespace.name}:${node.name.name.name}` : node.name.name);
+		if (t.isJSXSpreadAttribute(node)) {
+			firstSpread = true;
+			if (runningObject.length) {
+				spreadArgs.push(t.objectExpression(runningObject));
+				runningObject = [];
+			}
+			spreadArgs.push(isDynamic(attribute.get("argument"), { checkMember: true }) && (dynamicSpread = true) ? t.isCallExpression(node.argument) && !node.argument.arguments.length && !t.isCallExpression(node.argument.callee) && !t.isMemberExpression(node.argument.callee) ? node.argument.callee : t.arrowFunctionExpression([], node.argument) : node.argument);
+		} else if ((firstSpread || t.isJSXExpressionContainer(node.value) && isDynamic(attribute.get("value").get("expression"), { checkMember: true })) && canNativeSpread(key, { checkNameSpaces: true })) {
+			const isContainer = t.isJSXExpressionContainer(node.value);
+			if (isContainer && isDynamic(attribute.get("value").get("expression"), { checkMember: true })) {
+				const id = convertJSXIdentifier(node.name);
+				let expr = wrapConditionals && (t.isLogicalExpression(node.value.expression) || t.isConditionalExpression(node.value.expression)) ? transformCondition(attribute.get("value").get("expression"), true) : t.arrowFunctionExpression([], node.value.expression);
+				runningObject.push(t.objectMethod("get", id, [], t.blockStatement([t.returnStatement(expr.body)]), !t.isValidIdentifier(key)));
+			} else runningObject.push(t.objectProperty(t.stringLiteral(key), isContainer ? node.value.expression : node.value || t.booleanLiteral(true)));
+		} else filteredAttributes.push(attribute);
+	});
+	if (runningObject.length) spreadArgs.push(t.objectExpression(runningObject));
+	const props = spreadArgs.length === 1 && !dynamicSpread ? spreadArgs[0] : t.callExpression(registerImportMethod(path, "mergeProps"), spreadArgs);
+	return [filteredAttributes, t.expressionStatement(t.callExpression(registerImportMethod(path, "spread", getRendererConfig(path, "universal").moduleName), [
+		elem,
+		props,
+		t.booleanLiteral(hasChildren)
+	]))];
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/universal/template.ts
+function createTemplate$1(path, result, wrap) {
+	const config = getConfig(path);
+	if (result.id) {
+		result.decl = t.variableDeclaration("var", result.declarations);
+		if (!(result.exprs.length || result.dynamics.length || result.postExprs.length) && result.decl.declarations.length === 1) return result.decl.declarations[0].init;
+		else return t.callExpression(t.arrowFunctionExpression([], t.blockStatement([
+			result.decl,
+			...result.exprs.concat(wrapDynamics$1(path, result.dynamics) || [], result.postExprs || []),
+			t.returnStatement(result.id)
+		])), []);
+	}
+	if (wrap && result.dynamic && config.memoWrapper) return t.callExpression(registerImportMethod(path, config.memoWrapper), [result.exprs[0]]);
+	return result.exprs[0];
+}
+function wrapDynamics$1(path, dynamics) {
+	if (!dynamics.length) return;
+	const effectWrapperId = registerImportMethod(path, getConfig(path).effectWrapper);
+	if (dynamics.length === 1) {
+		const prevValue = t.identifier("_$p");
+		return t.expressionStatement(t.callExpression(effectWrapperId, [t.arrowFunctionExpression([prevValue], setAttr$1(path, dynamics[0].elem, dynamics[0].key, dynamics[0].value, {
+			dynamic: true,
+			prevId: prevValue
+		}))]));
+	}
+	const prevId = t.identifier("_p$");
+	/** @type {t.VariableDeclarator[]} */
+	const declarations = [];
+	/** @type {t.ExpressionStatement[]} */
+	const statements = [];
+	/** @type {t.Identifier[]} */
+	const properties = [];
+	dynamics.forEach(({ elem, key, value }, index) => {
+		const varIdent = path.scope.generateUidIdentifier("v$");
+		const propIdent = t.identifier(getNumberedId(index));
+		const propMember = t.memberExpression(prevId, propIdent);
+		properties.push(propIdent);
+		declarations.push(t.variableDeclarator(varIdent, value));
+		statements.push(t.expressionStatement(t.logicalExpression("&&", t.binaryExpression("!==", varIdent, propMember), t.assignmentExpression("=", propMember, setAttr$1(path, elem, key, varIdent, {
+			dynamic: true,
+			prevId: propMember
+		})))));
+	});
+	return t.expressionStatement(t.callExpression(effectWrapperId, [t.arrowFunctionExpression([prevId], t.blockStatement([
+		t.variableDeclaration("var", declarations),
+		...statements,
+		t.returnStatement(prevId)
+	])), t.objectExpression(properties.map((id) => t.objectProperty(id, t.identifier("undefined"))))]));
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/component.ts
+function convertComponentIdentifier(node) {
+	if (t.isJSXIdentifier(node)) {
+		if (node.name === "this") return t.thisExpression();
+		if (t.isValidIdentifier(node.name)) node.type = "Identifier";
+		else return t.stringLiteral(node.name);
+	} else if (t.isJSXMemberExpression(node)) {
+		const prop = convertComponentIdentifier(node.property);
+		const computed = t.isStringLiteral(prop);
+		return t.memberExpression(convertComponentIdentifier(node.object), prop, computed);
+	}
+	return node;
+}
+function transformComponent(path) {
+	let exprs = [], config = getConfig(path), tagId = convertComponentIdentifier(path.node.openingElement.name), props = [], runningObject = [], dynamicSpread = false, hasChildren = path.node.children.length > 0;
+	if (config.builtIns.indexOf(tagId.name) > -1 && !path.scope.hasBinding(tagId.name)) tagId.name = registerImportMethod(path, tagId.name).name;
+	path.get("openingElement").get("attributes").forEach((attribute) => {
+		const node = attribute.node;
+		if (t.isJSXSpreadAttribute(node)) {
+			if (runningObject.length) {
+				props.push(t.objectExpression(runningObject));
+				runningObject = [];
+			}
+			props.push(isDynamic(attribute.get("argument"), { checkMember: true }) && (dynamicSpread = true) ? t.isCallExpression(node.argument) && !node.argument.arguments.length && !t.isCallExpression(node.argument.callee) && !t.isMemberExpression(node.argument.callee) ? node.argument.callee : t.arrowFunctionExpression([], node.argument) : node.argument);
+		} else {
+			const value = (t.isStringLiteral(node.value) ? t.stringLiteral(node.value.value) : node.value) || t.booleanLiteral(true), id = convertJSXIdentifier(node.name), key = id.name;
+			if (hasChildren && key === "children") return;
+			if (t.isJSXExpressionContainer(value)) if (key === "ref") {
+				if (config.generate === "ssr") return;
+				while (t.isTSNonNullExpression(value.expression) || t.isTSAsExpression(value.expression) || t.isTSSatisfiesExpression(value.expression)) value.expression = value.expression.expression;
+				let binding, isConstant = t.isIdentifier(value.expression) && (binding = path.scope.getBinding(value.expression.name)) && (binding.kind === "const" || binding.kind === "module");
+				if (!isConstant && t.isLVal(value.expression)) {
+					const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+					runningObject.push(t.objectMethod("method", t.identifier("ref"), [t.identifier("r$")], t.blockStatement([t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(refIdentifier, [t.identifier("r$")]), t.assignmentExpression("=", value.expression, t.identifier("r$"))))])));
+				} else if (!isConstant && t.isOptionalMemberExpression(value.expression)) {
+					const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+					runningObject.push(t.objectMethod("method", t.identifier("ref"), [t.identifier("r$")], t.blockStatement([t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(refIdentifier, [t.identifier("r$")]), t.logicalExpression("&&", t.unaryExpression("!", t.unaryExpression("!", t.identifier(value.expression.object.name))), t.assignmentExpression("=", t.memberExpression(t.identifier(value.expression.object.name), t.identifier(value.expression.property.name)), t.identifier("r$")))))])));
+				} else if (isConstant || t.isFunction(value.expression)) runningObject.push(t.objectProperty(t.identifier("ref"), value.expression));
+				else if (t.isCallExpression(value.expression)) {
+					const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+					runningObject.push(t.objectMethod("method", t.identifier("ref"), [t.identifier("r$")], t.blockStatement([t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.logicalExpression("&&", t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(refIdentifier, [t.identifier("r$")])))])));
+				}
+			} else if (isDynamic(attribute.get("value").get("expression"), {
+				checkMember: true,
+				checkTags: true
+			})) if (config.wrapConditionals && config.generate !== "ssr" && (t.isLogicalExpression(value.expression) || t.isConditionalExpression(value.expression))) {
+				const expr = transformCondition(attribute.get("value").get("expression"), true);
+				runningObject.push(t.objectMethod("get", id, [], t.blockStatement([t.returnStatement(expr.body)]), !t.isValidIdentifier(key)));
+			} else if (t.isCallExpression(value.expression) && t.isArrowFunctionExpression(value.expression.callee) && value.expression.callee.params.length === 0) {
+				const callee = value.expression.callee;
+				const body = t.isBlockStatement(callee.body) ? callee.body : t.blockStatement([t.returnStatement(callee.body)]);
+				runningObject.push(t.objectMethod("get", id, [], body, !t.isValidIdentifier(key)));
+			} else runningObject.push(t.objectMethod("get", id, [], t.blockStatement([t.returnStatement(value.expression)]), !t.isValidIdentifier(key)));
+			else runningObject.push(t.objectProperty(id, value.expression));
+			else runningObject.push(t.objectProperty(id, value));
+		}
+	});
+	const childResult = transformComponentChildren(path.get("children"), config);
+	if (childResult && childResult[0]) if (childResult[1]) {
+		const body = t.isCallExpression(childResult[0]) && t.isFunction(childResult[0].arguments[0]) ? childResult[0].arguments[0].body : childResult[0].body ? childResult[0].body : childResult[0];
+		runningObject.push(t.objectMethod("get", t.identifier("children"), [], t.isExpression(body) ? t.blockStatement([t.returnStatement(body)]) : body));
+	} else runningObject.push(t.objectProperty(t.identifier("children"), childResult[0]));
+	if (runningObject.length || !props.length) props.push(t.objectExpression(runningObject));
+	if (props.length > 1 || dynamicSpread) props = [t.callExpression(registerImportMethod(path, "mergeProps"), props)];
+	const componentArgs = [tagId, props[0]];
+	exprs.push(t.callExpression(registerImportMethod(path, "createComponent"), componentArgs));
+	if (exprs.length > 1) {
+		const ret = exprs.pop();
+		exprs = [t.callExpression(t.arrowFunctionExpression([], t.blockStatement([...exprs, t.returnStatement(ret)])), [])];
+	}
+	return {
+		exprs,
+		template: "",
+		component: true
+	};
+}
+function transformComponentChildren(children, config) {
+	const filteredChildren = filterChildren(children);
+	if (!filteredChildren.length) return;
+	let dynamic = false;
+	let pathNodes = [];
+	let transformedChildren = filteredChildren.reduce((memo, path) => {
+		if (t.isJSXText(path.node)) {
+			const v$1 = decode(trimWhitespace(path.node.extra.raw));
+			if (v$1.length) {
+				pathNodes.push(path.node);
+				memo.push(t.stringLiteral(v$1));
+			}
+		} else {
+			const child = transformNode(path, {
+				topLevel: true,
+				componentChild: true,
+				lastElement: true
+			});
+			dynamic = dynamic || child.dynamic;
+			if (config.generate === "ssr" && filteredChildren.length > 1 && child.dynamic && t.isFunction(child.exprs[0])) child.exprs[0] = child.exprs[0].body;
+			pathNodes.push(path.node);
+			memo.push(getCreateTemplate(config, path, child)(path, child, filteredChildren.length > 1));
+		}
+		return memo;
+	}, []);
+	if (transformedChildren.length === 1) {
+		transformedChildren = transformedChildren[0];
+		if (!t.isJSXExpressionContainer(pathNodes[0]) && !t.isJSXSpreadChild(pathNodes[0]) && !t.isJSXText(pathNodes[0])) {
+			transformedChildren = t.isCallExpression(transformedChildren) && !transformedChildren.arguments.length && !t.isIdentifier(transformedChildren.callee) ? transformedChildren.callee : t.arrowFunctionExpression([], transformedChildren);
+			dynamic = true;
+		}
+	} else {
+		transformedChildren = t.arrowFunctionExpression([], t.arrayExpression(transformedChildren));
+		dynamic = true;
+	}
+	return [transformedChildren, dynamic];
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/fragment.ts
+function transformFragmentChildren(children, results, config) {
+	const childNodes = filterChildren(children).reduce((memo, path) => {
+		if (t.isJSXText(path.node)) {
+			const v$1 = decode(trimWhitespace(path.node.extra.raw));
+			if (v$1.length) memo.push(t.stringLiteral(v$1));
+		} else {
+			const child = transformNode(path, {
+				topLevel: true,
+				fragmentChild: true,
+				lastElement: true
+			});
+			memo.push(getCreateTemplate(config, path, child)(path, child, true));
+		}
+		return memo;
+	}, []);
+	results.exprs.push(childNodes.length === 1 ? childNodes[0] : t.arrayExpression(childNodes));
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/transform.ts
+function transformJSX(path, state) {
+	if (state.skip) return;
+	const config = getConfig(path);
+	const replace = transformThis(path);
+	const result = transformNode(path, t.isJSXFragment(path.node) ? {} : {
+		topLevel: true,
+		lastElement: true
+	});
+	const template$1 = getCreateTemplate(config, path, result);
+	path.replaceWith(replace(template$1(path, result, false)));
+	path.traverse({ enter(path$1) {
+		if (path$1.node.leadingComments && path$1.node.leadingComments[0] && path$1.node.leadingComments[0].value.trim() === config.staticMarker) path$1.node.leadingComments.shift();
+	} });
+}
+function getTargetFunctionParent(path, parent) {
+	let current = path.scope.getFunctionParent();
+	while (current !== parent && current.path.isArrowFunctionExpression()) current = current.path.parentPath.scope.getFunctionParent();
+	return current;
+}
+function transformThis(path) {
+	const parent = path.scope.getFunctionParent();
+	let thisId;
+	path.traverse({
+		ThisExpression(path$1) {
+			if (getTargetFunctionParent(path$1, parent) === parent) {
+				thisId || (thisId = path$1.scope.generateUidIdentifier("self$"));
+				path$1.replaceWith(thisId);
+			}
+		},
+		JSXElement(path$1) {
+			let source = path$1.get("openingElement").get("name");
+			while (source.isJSXMemberExpression()) source = source.get("object");
+			if (source.isJSXIdentifier() && source.node.name === "this") {
+				if (getTargetFunctionParent(path$1, parent) === parent) {
+					thisId || (thisId = path$1.scope.generateUidIdentifier("self$"));
+					source.replaceWith(t.jsxIdentifier(thisId.name));
+					if (path$1.node.closingElement) path$1.node.closingElement.name = path$1.node.openingElement.name;
+				}
+			}
+		}
+	});
+	return (node) => {
+		if (thisId) if (!parent || parent.block.type === "ClassMethod") {
+			const decl = t.variableDeclaration("const", [t.variableDeclarator(thisId, t.thisExpression())]);
+			if (parent) path.getStatementParent().insertBefore(decl);
+			else return t.callExpression(t.arrowFunctionExpression([], t.blockStatement([decl, t.returnStatement(node)])), []);
+		} else parent.push({
+			id: thisId,
+			init: t.thisExpression(),
+			kind: "const"
+		});
+		return node;
+	};
+}
+function transformNode(path, info = {}) {
+	const config = getConfig(path);
+	const node = path.node;
+	let staticValue;
+	if (t.isJSXElement(node)) return transformElement$1(config, path, info);
+	else if (t.isJSXFragment(node)) {
+		let results = {
+			template: "",
+			declarations: [],
+			exprs: [],
+			dynamics: []
+		};
+		transformFragmentChildren(path.get("children"), results, config);
+		return results;
+	} else if (t.isJSXText(node) || (staticValue = getStaticExpression(path)) !== false) {
+		const text = staticValue !== void 0 ? info.doNotEscape ? staticValue.toString() : escapeHTML(staticValue.toString()) : trimWhitespace(node.extra.raw);
+		if (!text.length) return null;
+		const results = {
+			template: text,
+			declarations: [],
+			exprs: [],
+			dynamics: [],
+			postExprs: [],
+			text: true
+		};
+		if (!info.skipId && config.generate !== "ssr") results.id = path.scope.generateUidIdentifier("el$");
+		return results;
+	} else if (t.isJSXExpressionContainer(node)) {
+		if (t.isJSXEmptyExpression(node.expression)) return null;
+		if (!isDynamic(path.get("expression"), {
+			checkMember: true,
+			checkTags: !!info.componentChild,
+			native: !info.componentChild
+		})) return {
+			exprs: [node.expression],
+			template: ""
+		};
+		const expr = config.wrapConditionals && config.generate !== "ssr" && (t.isLogicalExpression(node.expression) || t.isConditionalExpression(node.expression)) ? transformCondition(path.get("expression"), info.componentChild || info.fragmentChild) : !info.componentChild && (config.generate !== "ssr" || info.fragmentChild) && t.isCallExpression(node.expression) && !t.isCallExpression(node.expression.callee) && !t.isMemberExpression(node.expression.callee) && node.expression.arguments.length === 0 ? node.expression.callee : t.arrowFunctionExpression([], node.expression);
+		return {
+			exprs: expr.length > 1 ? [t.callExpression(t.arrowFunctionExpression([], t.blockStatement([expr[0], t.returnStatement(expr[1])])), [])] : [expr],
+			template: "",
+			dynamic: true
+		};
+	} else if (t.isJSXSpreadChild(node)) {
+		if (!isDynamic(path.get("expression"), {
+			checkMember: true,
+			native: !info.componentChild
+		})) return {
+			exprs: [node.expression],
+			template: ""
+		};
+		return {
+			exprs: [t.arrowFunctionExpression([], node.expression)],
+			template: "",
+			dynamic: true
+		};
+	}
+}
+function getCreateTemplate(config, path, result) {
+	if (result.tagName && result.renderer === "dom" || config.generate === "dom") return createTemplate;
+	if (result.renderer === "ssr" || config.generate === "ssr") return createTemplate$2;
+	return createTemplate$1;
+}
+function transformElement$1(config, path, info = {}) {
+	const node = path.node;
+	let tagName = getTagName(node);
+	if (isComponent(tagName)) return transformComponent(path);
+	if ((config.renderers ?? []).find((renderer) => renderer.elements.includes(tagName))?.name === "dom" || getConfig(path).generate === "dom") return transformElement(path, info);
+	if (getConfig(path).generate === "ssr") return transformElement$3(path, info);
+	return transformElement$2(path, info);
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/dom/constants.ts
+const InlineElements = [
+	"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",
+	"slot",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"svg",
+	"template",
+	"textarea",
+	"time",
+	"u",
+	"tt",
+	"var",
+	"video"
+];
+const BlockElements = [
+	"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"
+];
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/dom/element.ts
+const alwaysClose = [
+	"title",
+	"style",
+	"a",
+	"strong",
+	"small",
+	"b",
+	"u",
+	"i",
+	"em",
+	"s",
+	"code",
+	"object",
+	"table",
+	"button",
+	"textarea",
+	"select",
+	"iframe",
+	"script",
+	"noscript",
+	"template",
+	"fieldset"
+];
+function transformElement(path, info) {
+	let tagName = getTagName(path.node), config = getConfig(path), wrapSVG = info.topLevel && tagName != "svg" && SVGElements.has(tagName), voidTag = VoidElements_default.indexOf(tagName) > -1, isCustomElement = tagName.indexOf("-") > -1 || path.get("openingElement").get("attributes").some((a) => a.node?.name?.name === "is" || a.name?.name === "is"), isImportNode = (tagName === "img" || tagName === "iframe") && path.get("openingElement").get("attributes").some((a) => a.node.name?.name === "loading"), results = {
+		template: `<${tagName}`,
+		templateWithClosingTags: `<${tagName}`,
+		declarations: [],
+		exprs: [],
+		dynamics: [],
+		postExprs: [],
+		isSVG: wrapSVG,
+		hasCustomElement: isCustomElement,
+		isImportNode,
+		tagName,
+		renderer: "dom",
+		skipTemplate: false
+	};
+	path.get("openingElement").get("attributes").some((a) => {
+		if (a.node.name?.name === "data-hk") {
+			a.remove();
+			let filename = "";
+			try {
+				filename = path.scope.getProgramParent().path.hub.file.opts.filename;
+			} catch (e) {}
+			console.log("\n" + path.buildCodeFrameError(`"data-hk" attribute found in template, which could potentially cause hydration miss-matches. Usually happens when copying and pasting Solid SSRed code into JSX. Please remove the attribute from the JSX. \n\n${filename}\n`).toString());
+		}
+	});
+	if (config.hydratable && (tagName === "html" || tagName === "head" || tagName === "body")) {
+		results.skipTemplate = true;
+		if (tagName === "head" && info.topLevel) {
+			const createComponent = registerImportMethod(path, "createComponent", getRendererConfig(path, "dom").moduleName);
+			const NoHydration = registerImportMethod(path, "NoHydration", getRendererConfig(path, "dom").moduleName);
+			results.exprs.push(t.expressionStatement(t.callExpression(createComponent, [NoHydration, t.objectExpression([])])));
+			return results;
+		}
+	}
+	if (wrapSVG) {
+		results.template = "<svg>" + results.template;
+		results.templateWithClosingTags = "<svg>" + results.templateWithClosingTags;
+	}
+	if (!info.skipId) results.id = path.scope.generateUidIdentifier("el$");
+	transformAttributes(path, results);
+	if (config.contextToCustomElements && (tagName === "slot" || isCustomElement)) contextToCustomElement(path, results);
+	results.template += ">";
+	results.templateWithClosingTags += ">";
+	if (!voidTag) {
+		const toBeClosed = !info.lastElement || !config.omitLastClosingTag || info.toBeClosed && (!config.omitNestedClosingTags || info.toBeClosed.has(tagName));
+		if (toBeClosed) {
+			results.toBeClosed = new Set(info.toBeClosed || alwaysClose);
+			results.toBeClosed.add(tagName);
+			if (InlineElements.includes(tagName)) BlockElements.forEach((i) => results.toBeClosed.add(i));
+		} else results.toBeClosed = info.toBeClosed;
+		if (tagName !== "noscript") transformChildren(path, results, config);
+		if (toBeClosed) results.template += `</${tagName}>`;
+		results.templateWithClosingTags += `</${tagName}>`;
+	}
+	if (info.topLevel && config.hydratable && results.hasHydratableEvent) {
+		let runHydrationEvents = registerImportMethod(path, "runHydrationEvents", getRendererConfig(path, "dom").moduleName);
+		results.postExprs.push(t.expressionStatement(t.callExpression(runHydrationEvents, [])));
+	}
+	if (wrapSVG) {
+		results.template += "</svg>";
+		results.templateWithClosingTags += "</svg>";
+	}
+	return results;
+}
+function setAttr(path, elem, name, value, { isSVG, dynamic, prevId, isCE, tagName }) {
+	const config = getConfig(path);
+	let parts, namespace;
+	if ((parts = name.split(":")) && parts[1] && reservedNameSpaces.has(parts[0])) {
+		name = parts[1];
+		namespace = parts[0];
+	}
+	if (namespace === "style") {
+		const setStyleProperty = registerImportMethod(path, "setStyleProperty", getRendererConfig(path, "dom").moduleName);
+		return t.callExpression(setStyleProperty, [
+			elem,
+			t.stringLiteral(name),
+			t.isAssignmentExpression(value) && t.isIdentifier(value.left) ? value.right : value
+		]);
+	}
+	if (namespace === "class") return t.callExpression(t.memberExpression(t.memberExpression(elem, t.identifier("classList")), t.identifier("toggle")), [t.stringLiteral(name), dynamic ? value : t.unaryExpression("!", t.unaryExpression("!", value))]);
+	if (name === "style") return t.callExpression(registerImportMethod(path, "style", getRendererConfig(path, "dom").moduleName), prevId ? [
+		elem,
+		value,
+		prevId
+	] : [elem, value]);
+	if (!isSVG && name === "class") return t.callExpression(registerImportMethod(path, "className", getRendererConfig(path, "dom").moduleName), [elem, value]);
+	if (name === "classList") return t.callExpression(registerImportMethod(path, "classList", getRendererConfig(path, "dom").moduleName), prevId ? [
+		elem,
+		value,
+		prevId
+	] : [elem, value]);
+	if (dynamic && name === "textContent") {
+		if (config.hydratable) return t.callExpression(registerImportMethod(path, "setProperty"), [
+			elem,
+			t.stringLiteral("data"),
+			value
+		]);
+		return t.assignmentExpression("=", t.memberExpression(elem, t.identifier("data")), value);
+	}
+	if (namespace === "bool") return t.callExpression(registerImportMethod(path, "setBoolAttribute", getRendererConfig(path, "dom").moduleName), [
+		elem,
+		t.stringLiteral(name),
+		value
+	]);
+	const isChildProp = ChildProperties.has(name);
+	const isProp = Properties.has(name);
+	const alias = getPropAlias(name, tagName.toUpperCase());
+	if (namespace !== "attr" && (isChildProp || !isSVG && isProp || isCE || namespace === "prop")) {
+		if (isCE && !isChildProp && !isProp && namespace !== "prop") name = toPropertyName(name);
+		if (config.hydratable && namespace !== "prop") return t.callExpression(registerImportMethod(path, "setProperty"), [
+			elem,
+			t.stringLiteral(alias || name),
+			value
+		]);
+		return t.assignmentExpression("=", t.memberExpression(elem, t.identifier(alias || name)), value);
+	}
+	let isNameSpaced = name.indexOf(":") > -1;
+	name = Aliases[name] || name;
+	!isSVG && (name = name.toLowerCase());
+	const ns = isNameSpaced && SVGNamespace[name.split(":")[0]];
+	if (ns) return t.callExpression(registerImportMethod(path, "setAttributeNS", getRendererConfig(path, "dom").moduleName), [
+		elem,
+		t.stringLiteral(ns),
+		t.stringLiteral(name),
+		value
+	]);
+	else return t.callExpression(registerImportMethod(path, "setAttribute", getRendererConfig(path, "dom").moduleName), [
+		elem,
+		t.stringLiteral(name),
+		value
+	]);
+}
+function detectResolvableEventHandler(attribute, handler) {
+	while (t.isIdentifier(handler)) {
+		const lookup = attribute.scope.getBinding(handler.name);
+		if (lookup) if (t.isVariableDeclarator(lookup.path.node)) handler = lookup.path.node.init;
+		else if (t.isFunctionDeclaration(lookup.path.node)) return true;
+		else return false;
+		else return false;
+	}
+	return t.isFunction(handler);
+}
+function transformAttributes(path, results) {
+	let elem = results.id, hasHydratableEvent = false, children, spreadExpr, attributes = path.get("openingElement").get("attributes");
+	const tagName = getTagName(path.node), isSVG = SVGElements.has(tagName), isCE = tagName.includes("-") || attributes.some((a) => a.node.name?.name === "is"), hasChildren = path.node.children.length > 0, config = getConfig(path);
+	if (attributes.some((attribute) => t.isJSXSpreadAttribute(attribute.node))) {
+		[attributes, spreadExpr] = processSpreads(path, attributes, {
+			elem,
+			isSVG,
+			hasChildren,
+			wrapConditionals: config.wrapConditionals
+		});
+		path.get("openingElement").set("attributes", attributes.map((a) => a.node));
+		hasHydratableEvent = true;
+	}
+	/**
+	* Inline styles
+	*
+	* 1. When string
+	* 2. When is an object, the key is a string, and value is string/numeric
+	* 3. Remove properties from object when value is undefined/null
+	* 4. When `value.evaluate().confident`
+	*
+	* Also, when `key` is computed value is also `value.evaluate().confident`
+	*/
+	attributes = path.get("openingElement").get("attributes");
+	const styleAttributes = attributes.filter((a) => a.node.name && a.node.name.name === "style");
+	if (styleAttributes.length > 0) {
+		let inlinedStyle = "";
+		for (let i = 0; i < styleAttributes.length; i++) {
+			const attr = styleAttributes[i];
+			let value = attr.node.value;
+			const node = attr.get("value");
+			if (t.isJSXExpressionContainer(value)) value = value.expression;
+			if (t.isStringLiteral(value)) {
+				inlinedStyle += `${value.value.replace(/;$/, "")};`;
+				attr.remove();
+			} else if (t.isObjectExpression(value)) {
+				const properties = value.properties;
+				const propertiesNode = node.get("expression").get("properties");
+				const toRemoveProperty = [];
+				for (let i$1 = 0; i$1 < properties.length; i$1++) {
+					const property = properties[i$1];
+					if (property.computed) {
+						const r = propertiesNode[i$1].get("value").evaluate();
+						if (r.confident && (typeof r.value === "string" || typeof r.value === "number")) property.value = t.inherits(t.stringLiteral(`${r.value}`), property.value);
+						continue;
+					}
+					if (t.isObjectProperty(property)) {
+						const key = t.isIdentifier(property.key) ? property.key.name : property.key.value;
+						if (t.isStringLiteral(property.value) || t.isNumericLiteral(property.value)) {
+							inlinedStyle += `${key}:${property.value.value};`;
+							toRemoveProperty.push(property);
+						} else if (t.isIdentifier(property.value) && property.value.name === "undefined" || t.isNullLiteral(property.value)) toRemoveProperty.push(property);
+						else {
+							const r = propertiesNode[i$1].get("value").evaluate();
+							if (r.confident && (typeof r.value === "string" || typeof r.value === "number")) {
+								inlinedStyle += `${key}:${r.value};`;
+								toRemoveProperty.push(property);
+							}
+						}
+					}
+				}
+				for (const remove of toRemoveProperty) value.properties.splice(value.properties.indexOf(remove), 1);
+				if (value.properties.length === 0) attr.remove();
+			}
+		}
+		if (inlinedStyle !== "") {
+			const styleAttribute$1 = t.jsxAttribute(t.jsxIdentifier("style"), t.stringLiteral(inlinedStyle.replace(/;$/, "")));
+			path.get("openingElement").node.attributes.push(styleAttribute$1);
+		}
+	}
+	const styleAttribute = path.get("openingElement").get("attributes").find((a) => a.node.name && a.node.name.name === "style" && t.isJSXExpressionContainer(a.node.value) && t.isObjectExpression(a.node.value.expression) && !a.node.value.expression.properties.some((p) => t.isSpreadElement(p)));
+	if (styleAttribute) {
+		let i = 0, leading = styleAttribute.node.value.expression.leadingComments;
+		styleAttribute.node.value.expression.properties.slice().forEach((p, index) => {
+			if (!p.computed) {
+				if (leading) p.value.leadingComments = leading;
+				path.get("openingElement").node.attributes.splice(styleAttribute.key + ++i, 0, t.jsxAttribute(t.jsxNamespacedName(t.jsxIdentifier("style"), t.jsxIdentifier(t.isIdentifier(p.key) ? p.key.name : p.key.value)), t.jsxExpressionContainer(p.value)));
+				styleAttribute.node.value.expression.properties.splice(index - i - 1, 1);
+			}
+		});
+		if (!styleAttribute.node.value.expression.properties.length) path.get("openingElement").node.attributes.splice(styleAttribute.key, 1);
+	}
+	attributes = path.get("openingElement").get("attributes");
+	const classListAttribute = attributes.find((a) => a.node.name && a.node.name.name === "classList" && t.isJSXExpressionContainer(a.node.value) && t.isObjectExpression(a.node.value.expression) && !a.node.value.expression.properties.some((p) => t.isSpreadElement(p) || p.computed || t.isStringLiteral(p.key) && (p.key.value.includes(" ") || p.key.value.includes(":"))));
+	if (classListAttribute) {
+		let i = 0, leading = classListAttribute.node.value.expression.leadingComments, classListProperties = classListAttribute.get("value").get("expression").get("properties");
+		classListProperties.slice().forEach((propPath, index) => {
+			const p = propPath.node;
+			const { confident, value: computed } = propPath.get("value").evaluate();
+			if (leading) p.value.leadingComments = leading;
+			if (!confident) path.get("openingElement").node.attributes.splice(classListAttribute.key + ++i, 0, t.jsxAttribute(t.jsxNamespacedName(t.jsxIdentifier("class"), t.jsxIdentifier(t.isIdentifier(p.key) ? p.key.name : p.key.value)), t.jsxExpressionContainer(p.value)));
+			else if (computed) path.get("openingElement").node.attributes.splice(classListAttribute.key + ++i, 0, t.jsxAttribute(t.jsxIdentifier("class"), t.stringLiteral(t.isIdentifier(p.key) ? p.key.name : p.key.value)));
+			classListProperties.splice(index - i - 1, 1);
+		});
+		if (!classListProperties.length) path.get("openingElement").node.attributes.splice(classListAttribute.key, 1);
+	}
+	attributes = path.get("openingElement").get("attributes");
+	const classAttributes = attributes.filter((a) => a.node.name && (a.node.name.name === "class" || a.node.name.name === "className"));
+	if (classAttributes.length > 1) {
+		const first = classAttributes[0].node, values = [], quasis = [t.templateElement({ raw: "" })];
+		for (let i = 0; i < classAttributes.length; i++) {
+			const attr = classAttributes[i].node, isLast = i === classAttributes.length - 1;
+			if (!t.isJSXExpressionContainer(attr.value)) {
+				const prev = quasis.pop();
+				quasis.push(t.templateElement({ raw: (prev ? prev.value.raw : "") + `${attr.value.value}` + (isLast ? "" : " ") }));
+			} else {
+				values.push(t.logicalExpression("||", attr.value.expression, t.stringLiteral("")));
+				quasis.push(t.templateElement({ raw: isLast ? "" : " " }));
+			}
+			i && attributes.splice(attributes.indexOf(classAttributes[i]), 1);
+		}
+		if (values.length) first.value = t.jsxExpressionContainer(t.templateLiteral(quasis, values));
+		else first.value = t.stringLiteral(quasis[0].value.raw);
+	}
+	path.get("openingElement").set("attributes", attributes.map((a) => a.node));
+	let needsSpacing = true;
+	function inlineAttributeOnTemplate(isSVG$1, key, results$1, value) {
+		!isSVG$1 && (key = key.toLowerCase());
+		results$1.template += `${needsSpacing ? " " : ""}${key}`;
+		if (!value) {
+			needsSpacing = true;
+			return;
+		}
+		let text = value.value;
+		if (typeof text === "number") text = String(text);
+		let needsQuoting = !config.omitQuotes;
+		if (key === "style" || key === "class") {
+			text = trimWhitespace(text);
+			if (key === "style") text = text.replace(/; /g, ";").replace(/: /g, ":");
+		}
+		if (!text.length) {
+			needsSpacing = true;
+			results$1.template += ``;
+			return;
+		}
+		for (let i = 0, len = text.length; i < len; i++) {
+			let char = text[i];
+			if (char === "'" || char === "\"" || char === " " || char === "	" || char === "\n" || char === "\r" || char === "`" || char === "=" || char === "<" || char === ">") needsQuoting = true;
+		}
+		if (needsQuoting) {
+			needsSpacing = false;
+			results$1.template += `="${escapeHTML(text, true)}"`;
+		} else {
+			needsSpacing = true;
+			results$1.template += `=${escapeHTML(text, true)}`;
+		}
+	}
+	path.get("openingElement").get("attributes").forEach((attribute) => {
+		const node = attribute.node;
+		let value = node.value, key = t.isJSXNamespacedName(node.name) ? `${node.name.namespace.name}:${node.name.name.name}` : node.name.name, reservedNameSpace = t.isJSXNamespacedName(node.name) && reservedNameSpaces.has(node.name.namespace.name);
+		if (t.isJSXExpressionContainer(value) && !key.startsWith("use:")) {
+			const evaluated = attribute.get("value").get("expression").evaluate().value;
+			let type;
+			if (evaluated !== void 0 && ((type = typeof evaluated) === "string" || type === "number")) if (type === "number" && (Properties.has(key) || key.startsWith("prop:"))) value = t.jsxExpressionContainer(t.numericLiteral(evaluated));
+			else value = t.stringLiteral(String(evaluated));
+		}
+		if (t.isJSXNamespacedName(node.name) && reservedNameSpace && !t.isJSXExpressionContainer(value)) node.value = value = t.jsxExpressionContainer(value || t.jsxEmptyExpression());
+		if (t.isJSXExpressionContainer(value) && (reservedNameSpace || !(t.isStringLiteral(value.expression) || t.isNumericLiteral(value.expression)))) if (key === "ref") {
+			while (t.isTSNonNullExpression(value.expression) || t.isTSAsExpression(value.expression)) value.expression = value.expression.expression;
+			let binding, isConstant = t.isIdentifier(value.expression) && (binding = path.scope.getBinding(value.expression.name)) && (binding.kind === "const" || binding.kind === "module");
+			if (!isConstant && t.isLVal(value.expression)) {
+				const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+				results.exprs.unshift(t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.conditionalExpression(t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "dom").moduleName), [refIdentifier, elem]), t.assignmentExpression("=", value.expression, elem))));
+			} else if (isConstant || t.isFunction(value.expression)) results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "dom").moduleName), [value.expression, elem])));
+			else {
+				const refIdentifier = path.scope.generateUidIdentifier("_ref$");
+				results.exprs.unshift(t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, value.expression)]), t.expressionStatement(t.logicalExpression("&&", t.binaryExpression("===", t.unaryExpression("typeof", refIdentifier), t.stringLiteral("function")), t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "dom").moduleName), [refIdentifier, elem]))));
+			}
+		} else if (key.startsWith("use:")) {
+			node.name.name.type = "Identifier";
+			results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "use", getRendererConfig(path, "dom").moduleName), [
+				node.name.name,
+				elem,
+				t.arrowFunctionExpression([], t.isJSXEmptyExpression(value.expression) ? t.booleanLiteral(true) : value.expression)
+			])));
+		} else if (key === "children") children = value;
+		else if (key.startsWith("on")) {
+			const ev = toEventName(key);
+			if (key.startsWith("on:")) {
+				const args = [
+					elem,
+					t.stringLiteral(key.split(":")[1]),
+					value.expression
+				];
+				results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "addEventListener", getRendererConfig(path, "dom").moduleName), args)));
+			} else if (key.startsWith("oncapture:")) {
+				const args = [
+					t.stringLiteral(key.split(":")[1]),
+					value.expression,
+					t.booleanLiteral(true)
+				];
+				results.exprs.push(t.expressionStatement(t.callExpression(t.memberExpression(elem, t.identifier("addEventListener")), args)));
+			} else if (config.delegateEvents && (DelegatedEvents.has(ev) || config.delegatedEvents.indexOf(ev) !== -1)) {
+				hasHydratableEvent = true;
+				(attribute.scope.getProgramParent().data.events || (attribute.scope.getProgramParent().data.events = /* @__PURE__ */ new Set())).add(ev);
+				let handler = value.expression;
+				const resolveable = detectResolvableEventHandler(attribute, handler);
+				if (t.isArrayExpression(handler)) {
+					if (handler.elements.length > 1) results.exprs.unshift(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(elem, t.identifier(`$$${ev}Data`)), handler.elements[1])));
+					handler = handler.elements[0];
+					results.exprs.unshift(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(elem, t.identifier(`$$${ev}`)), handler)));
+				} else if (t.isFunction(handler) || resolveable) results.exprs.unshift(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(elem, t.identifier(`$$${ev}`)), handler)));
+				else results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "addEventListener", getRendererConfig(path, "dom").moduleName), [
+					elem,
+					t.stringLiteral(ev),
+					handler,
+					t.booleanLiteral(true)
+				])));
+			} else {
+				let handler = value.expression;
+				const resolveable = detectResolvableEventHandler(attribute, handler);
+				if (t.isArrayExpression(handler)) {
+					if (handler.elements.length > 1) handler = t.arrowFunctionExpression([t.identifier("e")], t.callExpression(handler.elements[0], [handler.elements[1], t.identifier("e")]));
+					else handler = handler.elements[0];
+					results.exprs.unshift(t.expressionStatement(t.callExpression(t.memberExpression(elem, t.identifier("addEventListener")), [t.stringLiteral(ev), handler])));
+				} else if (t.isFunction(handler) || resolveable) results.exprs.unshift(t.expressionStatement(t.callExpression(t.memberExpression(elem, t.identifier("addEventListener")), [t.stringLiteral(ev), handler])));
+				else results.exprs.unshift(t.expressionStatement(t.callExpression(registerImportMethod(path, "addEventListener", getRendererConfig(path, "dom").moduleName), [
+					elem,
+					t.stringLiteral(ev),
+					handler
+				])));
+			}
+		} else if (config.effectWrapper && (isDynamic(attribute.get("value").get("expression"), { checkMember: true }) || (key === "classList" || key === "style") && !attribute.get("value").get("expression").evaluate().confident && !hasStaticMarker(value, path))) {
+			let nextElem = elem;
+			if (key === "value" || key === "checked") {
+				const effectWrapperId = registerImportMethod(path, config.effectWrapper);
+				results.postExprs.push(t.expressionStatement(t.callExpression(effectWrapperId, [t.arrowFunctionExpression([], setAttr(path, elem, key, value.expression, {
+					tagName,
+					isSVG,
+					isCE
+				}))])));
+				return;
+			}
+			if (key === "textContent") {
+				nextElem = attribute.scope.generateUidIdentifier("el$");
+				children = t.jsxText(" ");
+				children.extra = {
+					raw: " ",
+					rawValue: " "
+				};
+				results.declarations.push(t.variableDeclarator(nextElem, t.memberExpression(elem, t.identifier("firstChild"))));
+			}
+			results.dynamics.push({
+				elem: nextElem,
+				key,
+				value: value.expression,
+				isSVG,
+				isCE,
+				tagName
+			});
+		} else if (key.slice(0, 5) === "attr:") {
+			if (t.isJSXExpressionContainer(value)) value = value.expression;
+			if (t.isStringLiteral(value) || t.isNumericLiteral(value)) inlineAttributeOnTemplate(isSVG, key.slice(5), results, value);
+			else results.exprs.push(t.expressionStatement(setAttr(attribute, elem, key, value, {
+				isSVG,
+				isCE,
+				tagName
+			})));
+		} else if (key.slice(0, 5) === "bool:") {
+			let content = value;
+			if (t.isJSXExpressionContainer(content)) content = content.expression;
+			function addBoolAttribute() {
+				results.template += `${needsSpacing ? " " : ""}${key.slice(5)}`;
+				needsSpacing = true;
+			}
+			switch (content.type) {
+				case "StringLiteral":
+					if (content.value.length && content.value !== "0") addBoolAttribute();
+					return;
+				case "NullLiteral": return;
+				case "BooleanLiteral":
+					if (content.value) addBoolAttribute();
+					return;
+				case "Identifier":
+					if (content.name === "undefined") return;
+					break;
+			}
+			results.exprs.push(t.expressionStatement(setAttr(attribute, elem, key, t.isJSXExpressionContainer(value) ? value.expression : value, {
+				isSVG,
+				isCE,
+				tagName
+			})));
+		} else results.exprs.push(t.expressionStatement(setAttr(attribute, elem, key, value.expression, {
+			isSVG,
+			isCE,
+			tagName
+		})));
+		else {
+			if (config.hydratable && key === "$ServerOnly") {
+				results.skipTemplate = true;
+				return;
+			}
+			if (t.isJSXExpressionContainer(value)) value = value.expression;
+			key = Aliases[key] || key;
+			if (value && ChildProperties.has(key)) results.exprs.push(t.expressionStatement(setAttr(attribute, elem, key, value, {
+				isSVG,
+				isCE,
+				tagName
+			})));
+			else inlineAttributeOnTemplate(isSVG, key, results, value);
+		}
+	});
+	if (!hasChildren && children) path.node.children.push(children);
+	if (spreadExpr) results.exprs.push(spreadExpr);
+	results.hasHydratableEvent = results.hasHydratableEvent || hasHydratableEvent;
+}
+function findLastElement(children, hydratable) {
+	let lastElement = -1, tagName;
+	for (let i = children.length - 1; i >= 0; i--) {
+		const node = children[i].node;
+		if (hydratable || t.isJSXText(node) || getStaticExpression(children[i]) !== false || t.isJSXElement(node) && (tagName = getTagName(node)) && !isComponent(tagName)) {
+			lastElement = i;
+			break;
+		}
+	}
+	return lastElement;
+}
+function transformChildren(path, results, config) {
+	let tempPath = results.id && results.id.name, tagName = getTagName(path.node), nextPlaceholder, childPostExprs = [], i = 0;
+	const filteredChildren = filterChildren(path.get("children")), lastElement = findLastElement(filteredChildren, config.hydratable), childNodes = filteredChildren.reduce((memo, child, index) => {
+		if (child.isJSXFragment()) throw new Error(`Fragments can only be used top level in JSX. Not used under a <${tagName}>.`);
+		const transformed = transformNode(child, {
+			toBeClosed: results.toBeClosed,
+			lastElement: index === lastElement,
+			skipId: !results.id || !detectExpressions(filteredChildren, index, config)
+		});
+		if (!transformed) return memo;
+		const i$1 = memo.length;
+		if (transformed.text && i$1 && memo[i$1 - 1].text) {
+			memo[i$1 - 1].template += transformed.template;
+			memo[i$1 - 1].templateWithClosingTags += transformed.templateWithClosingTags || transformed.template;
+		} else memo.push(transformed);
+		return memo;
+	}, []);
+	childNodes.forEach((child, index) => {
+		if (!child) return;
+		if (child.tagName && child.renderer !== "dom") throw new Error(`<${child.tagName}> is not supported in <${tagName}>.
+      Wrap the usage with a component that would render this element, eg. Canvas`);
+		results.template += child.template;
+		results.templateWithClosingTags += child.templateWithClosingTags || child.template;
+		results.isImportNode = results.isImportNode || child.isImportNode;
+		if (child.id) {
+			if (child.tagName === "head") {
+				if (config.hydratable) {
+					const createComponent = registerImportMethod(path, "createComponent", getRendererConfig(path, "dom").moduleName);
+					const NoHydration = registerImportMethod(path, "NoHydration", getRendererConfig(path, "dom").moduleName);
+					results.exprs.push(t.expressionStatement(t.callExpression(createComponent, [NoHydration, t.objectExpression([])])));
+				}
+				return;
+			}
+			let getNextMatch;
+			if (config.hydratable && tagName === "html") getNextMatch = registerImportMethod(path, "getNextMatch", getRendererConfig(path, "dom").moduleName);
+			const walk = t.memberExpression(t.identifier(tempPath), t.identifier(i === 0 ? "firstChild" : "nextSibling"));
+			results.declarations.push(t.variableDeclarator(child.id, config.hydratable && tagName === "html" ? t.callExpression(getNextMatch, [walk, t.stringLiteral(child.tagName)]) : walk));
+			results.declarations.push(...child.declarations);
+			results.exprs.push(...child.exprs);
+			results.dynamics.push(...child.dynamics);
+			childPostExprs.push(...child.postExprs);
+			results.hasHydratableEvent = results.hasHydratableEvent || child.hasHydratableEvent;
+			results.hasCustomElement = results.hasCustomElement || child.hasCustomElement;
+			results.isImportNode = results.isImportNode || child.isImportNode;
+			tempPath = child.id.name;
+			nextPlaceholder = null;
+			i++;
+		} else if (child.exprs.length) {
+			let insert = registerImportMethod(path, "insert", getRendererConfig(path, "dom").moduleName);
+			const multi = checkLength(filteredChildren), markers = config.hydratable && multi;
+			if (markers || wrappedByText(childNodes, index)) {
+				let exprId, contentId;
+				if (markers) tempPath = createPlaceholder(path, results, tempPath, i++, "$")[0].name;
+				if (nextPlaceholder) exprId = nextPlaceholder;
+				else [exprId, contentId] = createPlaceholder(path, results, tempPath, i++, markers ? "/" : "");
+				if (!markers) nextPlaceholder = exprId;
+				results.exprs.push(t.expressionStatement(t.callExpression(insert, contentId ? [
+					results.id,
+					child.exprs[0],
+					exprId,
+					contentId
+				] : [
+					results.id,
+					child.exprs[0],
+					exprId
+				])));
+				tempPath = exprId.name;
+			} else if (multi) results.exprs.push(t.expressionStatement(t.callExpression(insert, [
+				results.id,
+				child.exprs[0],
+				nextChild(childNodes, index) || t.nullLiteral()
+			])));
+			else results.exprs.push(t.expressionStatement(t.callExpression(insert, [results.id, child.exprs[0]])));
+		} else nextPlaceholder = null;
+	});
+	results.postExprs.unshift(...childPostExprs);
+}
+function createPlaceholder(path, results, tempPath, i, char) {
+	const exprId = path.scope.generateUidIdentifier("el$"), config = getConfig(path);
+	let contentId;
+	results.template += `<!${char}>`;
+	results.templateWithClosingTags += `<!${char}>`;
+	if (config.hydratable && char === "/") {
+		contentId = path.scope.generateUidIdentifier("co$");
+		results.declarations.push(t.variableDeclarator(t.arrayPattern([exprId, contentId]), t.callExpression(registerImportMethod(path, "getNextMarker", getRendererConfig(path, "dom").moduleName), [t.memberExpression(t.identifier(tempPath), t.identifier("nextSibling"))])));
+	} else results.declarations.push(t.variableDeclarator(exprId, t.memberExpression(t.identifier(tempPath), t.identifier(i === 0 ? "firstChild" : "nextSibling"))));
+	return [exprId, contentId];
+}
+function nextChild(children, index) {
+	return children[index + 1] && (children[index + 1].id || nextChild(children, index + 1));
+}
+function detectExpressions(children, index, config) {
+	if (children[index - 1]) {
+		const node = children[index - 1].node;
+		if (t.isJSXExpressionContainer(node) && !t.isJSXEmptyExpression(node.expression) && getStaticExpression(children[index - 1]) === false) return true;
+		let tagName;
+		if (t.isJSXElement(node) && (tagName = getTagName(node)) && isComponent(tagName)) return true;
+	}
+	for (let i = index; i < children.length; i++) {
+		const child = children[i].node;
+		if (t.isJSXExpressionContainer(child)) {
+			if (!t.isJSXEmptyExpression(child.expression) && getStaticExpression(children[i]) === false) return true;
+		} else if (t.isJSXElement(child)) {
+			const tagName = getTagName(child);
+			if (isComponent(tagName)) return true;
+			if (config.contextToCustomElements && (tagName === "slot" || tagName.indexOf("-") > -1 || child.openingElement.attributes.some((a) => a.name?.name === "is"))) return true;
+			if (child.openingElement.attributes.some((attr) => t.isJSXSpreadAttribute(attr) || [
+				"textContent",
+				"innerHTML",
+				"innerText"
+			].includes(attr.name.name) || attr.name.namespace && (attr.name.namespace.name === "use" || attr.name.namespace.name === "prop") || t.isJSXExpressionContainer(attr.value) && !(t.isStringLiteral(attr.value.expression) || t.isNumericLiteral(attr.value.expression)))) return true;
+			const nextChildren = filterChildren(children[i].get("children"));
+			if (nextChildren.length) {
+				if (detectExpressions(nextChildren, 0, config)) return true;
+			}
+		}
+	}
+}
+function contextToCustomElement(path, results) {
+	results.exprs.push(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(results.id, t.identifier("_$owner")), t.callExpression(registerImportMethod(path, "getOwner", getRendererConfig(path, "dom").moduleName), []))));
+}
+function processSpreads(path, attributes, { elem, isSVG, hasChildren, wrapConditionals }) {
+	const config = getConfig(path);
+	const filteredAttributes = [];
+	const spreadArgs = [];
+	let runningObject = [];
+	let dynamicSpread = false;
+	let firstSpread = false;
+	attributes.forEach((attribute) => {
+		const node = attribute.node;
+		const key = !t.isJSXSpreadAttribute(node) && (t.isJSXNamespacedName(node.name) ? `${node.name.namespace.name}:${node.name.name.name}` : node.name.name);
+		if (t.isJSXSpreadAttribute(node)) {
+			const isStatic = node.innerComments && node.innerComments[0] && node.innerComments[0].value.trim() === config.staticMarker;
+			firstSpread = true;
+			if (runningObject.length) {
+				spreadArgs.push(t.objectExpression(runningObject));
+				runningObject = [];
+			}
+			const s = isDynamic(attribute.get("argument"), { checkMember: true }) && (dynamicSpread = true) ? t.isCallExpression(node.argument) && !node.argument.arguments.length && !t.isCallExpression(node.argument.callee) && !t.isMemberExpression(node.argument.callee) ? node.argument.callee : t.arrowFunctionExpression([], node.argument) : node.argument;
+			spreadArgs.push(isStatic ? t.objectExpression([t.spreadElement(s)]) : s);
+		} else if ((firstSpread || t.isJSXExpressionContainer(node.value) && isDynamic(attribute.get("value").get("expression"), { checkMember: true })) && canNativeSpread(key, { checkNameSpaces: true })) {
+			const isContainer = t.isJSXExpressionContainer(node.value);
+			if (isContainer && isDynamic(attribute.get("value").get("expression"), { checkMember: true })) {
+				const id = convertJSXIdentifier(node.name);
+				let expr = wrapConditionals && (t.isLogicalExpression(node.value.expression) || t.isConditionalExpression(node.value.expression)) ? transformCondition(attribute.get("value").get("expression"), true) : t.arrowFunctionExpression([], node.value.expression);
+				runningObject.push(t.objectMethod("get", id, [], t.blockStatement([t.returnStatement(expr.body)]), !t.isValidIdentifier(key)));
+			} else runningObject.push(t.objectProperty(t.stringLiteral(key), isContainer ? node.value.expression : node.value || (Properties.has(key) ? t.booleanLiteral(true) : t.stringLiteral(""))));
+		} else filteredAttributes.push(attribute);
+	});
+	if (runningObject.length) spreadArgs.push(t.objectExpression(runningObject));
+	const props = spreadArgs.length === 1 && !dynamicSpread ? spreadArgs[0] : t.callExpression(registerImportMethod(path, "mergeProps"), spreadArgs);
+	return [filteredAttributes, t.expressionStatement(t.callExpression(registerImportMethod(path, "spread", getRendererConfig(path, "dom").moduleName), [
+		elem,
+		props,
+		t.booleanLiteral(isSVG),
+		t.booleanLiteral(hasChildren)
+	]))];
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/dom/template.ts
+function createTemplate(path, result, wrap) {
+	const config = getConfig(path);
+	if (result.id) {
+		registerTemplate(path, result);
+		if (!(result.exprs.length || result.dynamics.length || result.postExprs.length) && result.decl.declarations.length === 1) return result.decl.declarations[0].init;
+		else return t.callExpression(t.arrowFunctionExpression([], t.blockStatement([
+			result.decl,
+			...result.exprs.concat(wrapDynamics(path, result.dynamics) || [], result.postExprs || []),
+			t.returnStatement(result.id)
+		])), []);
+	}
+	if (wrap && result.dynamic && config.memoWrapper) return t.callExpression(registerImportMethod(path, config.memoWrapper), [result.exprs[0]]);
+	return result.exprs[0];
+}
+function appendTemplates(path, templates) {
+	const declarators = templates.map((template$1) => {
+		const tmpl = {
+			cooked: template$1.template,
+			raw: escapeStringForTemplate(template$1.template)
+		};
+		const shouldUseImportNode = template$1.isCE || template$1.isImportNode;
+		const isMathML = /^<(math|annotation|annotation-xml|maction|math|merror|mfrac|mi|mmultiscripts|mn|mo|mover|mpadded|mphantom|mprescripts|mroot|mrow|ms|mspace|msqrt|mstyle|msub|msubsup|msup|mtable|mtd|mtext|mtr|munder|munderover|semantics|menclose|mfenced)(\s|>)/.test(template$1.template);
+		return t.variableDeclarator(template$1.id, t.addComment(t.callExpression(registerImportMethod(path, "template", getRendererConfig(path, "dom").moduleName), [t.templateLiteral([t.templateElement(tmpl, true)], [])].concat(template$1.isSVG || shouldUseImportNode || isMathML ? [
+			t.booleanLiteral(!!shouldUseImportNode),
+			t.booleanLiteral(template$1.isSVG),
+			t.booleanLiteral(isMathML)
+		] : [])), "leading", "#__PURE__"));
+	});
+	path.node.body.unshift(t.variableDeclaration("var", declarators));
+}
+function registerTemplate(path, results) {
+	const { hydratable } = getConfig(path);
+	let decl;
+	if (results.template.length) {
+		let templateDef, templateId;
+		if (!results.skipTemplate) {
+			const templates = path.scope.getProgramParent().data.templates || (path.scope.getProgramParent().data.templates = []);
+			if (templateDef = templates.find((t$1) => t$1.template === results.template)) templateId = templateDef.id;
+			else {
+				templateId = path.scope.generateUidIdentifier("tmpl$");
+				templates.push({
+					id: templateId,
+					template: results.template,
+					templateWithClosingTags: results.templateWithClosingTags,
+					isSVG: results.isSVG,
+					isCE: results.hasCustomElement,
+					isImportNode: results.isImportNode,
+					renderer: "dom"
+				});
+			}
+		}
+		decl = t.variableDeclarator(results.id, hydratable ? t.callExpression(registerImportMethod(path, "getNextElement", getRendererConfig(path, "dom").moduleName), templateId ? [templateId] : []) : t.callExpression(templateId, []));
+	}
+	results.declarations.unshift(decl);
+	results.decl = t.variableDeclaration("var", results.declarations);
+}
+function wrapDynamics(path, dynamics) {
+	if (!dynamics.length) return;
+	const effectWrapperId = registerImportMethod(path, getConfig(path).effectWrapper);
+	if (dynamics.length === 1) {
+		let dynamicStyle;
+		const prevValue = dynamics[0].key === "classList" || dynamics[0].key === "style" || (dynamicStyle = dynamics[0].key.startsWith("style:")) ? t.identifier("_$p") : void 0;
+		if (dynamicStyle) dynamics[0].value = t.assignmentExpression("=", prevValue, dynamics[0].value);
+		else if (dynamics[0].key.startsWith("class:") && !t.isBooleanLiteral(dynamics[0].value) && !t.isUnaryExpression(dynamics[0].value)) dynamics[0].value = t.unaryExpression("!", t.unaryExpression("!", dynamics[0].value));
+		return t.expressionStatement(t.callExpression(effectWrapperId, [t.arrowFunctionExpression(prevValue ? [prevValue] : [], setAttr(path, dynamics[0].elem, dynamics[0].key, dynamics[0].value, {
+			isSVG: dynamics[0].isSVG,
+			isCE: dynamics[0].isCE,
+			tagName: dynamics[0].tagName,
+			dynamic: true,
+			prevId: prevValue
+		}))]));
+	}
+	const prevId = t.identifier("_p$");
+	/** @type {t.VariableDeclarator[]} */
+	const declarations = [];
+	/** @type {t.ExpressionStatement[]} */
+	const statements = [];
+	/** @type {t.Identifier[]} */
+	const properties = [];
+	dynamics.forEach(({ elem, key, value, isSVG, isCE, tagName }, index) => {
+		const varIdent = path.scope.generateUidIdentifier("v$");
+		const propIdent = t.identifier(getNumberedId(index));
+		const propMember = t.memberExpression(prevId, propIdent);
+		if (key.startsWith("class:") && !t.isBooleanLiteral(value) && !t.isUnaryExpression(value)) value = t.unaryExpression("!", t.unaryExpression("!", value));
+		properties.push(propIdent);
+		declarations.push(t.variableDeclarator(varIdent, value));
+		if (key === "classList" || key === "style") statements.push(t.expressionStatement(t.assignmentExpression("=", propMember, setAttr(path, elem, key, varIdent, {
+			isSVG,
+			isCE,
+			tagName,
+			dynamic: true,
+			prevId: propMember
+		}))));
+		else {
+			const prev = key.startsWith("style:") ? varIdent : void 0;
+			statements.push(t.expressionStatement(t.logicalExpression("&&", t.binaryExpression("!==", varIdent, propMember), setAttr(path, elem, key, t.assignmentExpression("=", propMember, varIdent), {
+				isSVG,
+				isCE,
+				tagName,
+				dynamic: true,
+				prevId: prev
+			}))));
+		}
+	});
+	return t.expressionStatement(t.callExpression(effectWrapperId, [t.arrowFunctionExpression([prevId], t.blockStatement([
+		t.variableDeclaration("var", declarations),
+		...statements,
+		t.returnStatement(prevId)
+	])), t.objectExpression(properties.map((id) => t.objectProperty(id, t.identifier("undefined"))))]));
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/validate.ts
+/** `bodyElement` will be used as a `context` (The place where we run `innerHTML`) */
+const bodyElement = parse5.parse(`<!DOCTYPE html><html><head></head><body></body></html>`).childNodes[1].childNodes[1];
+function innerHTML(htmlFragment) {
+	/** `htmlFragment` will be parsed as if it was set to the `bodyElement`'s `innerHTML` property. */
+	const parsedFragment = parse5.parseFragment(bodyElement, htmlFragment);
+	/** `serialize` returns back a string from the parsed nodes */
+	return parse5.serialize(parsedFragment);
+}
+/**
+* Returns an object with information when the markup is invalid
+*
+* @param {string} html - The html string to validate
+* @returns {{
+*   html: string; // html stripped of attributives and content
+*   browser: string; // what the browser returned from evaluating `html`
+* } | null}
+*/
+function isInvalidMarkup(html) {
+	html = html.replaceAll("<!>", "<!---->").replaceAll("<!$>", "<!--$-->").replaceAll("<!/>", "<!--/-->").replace(/^[^<]+/, "#text").replace(/[^>]+$/, "#text").replace(/>[^<]+</gi, ">#text<").replace(/&lt;([^>]+)>/gi, "&lt;$1&gt;");
+	if (/^<(td|th)>/.test(html)) html = `<table><tbody><tr>${html}</tr></tbody></table>`;
+	if (/^<tr>/.test(html)) html = `<table><tbody>${html}</tbody></table>`;
+	if (/^<col>/.test(html)) html = `<table><colgroup>${html}</colgroup></table>`;
+	if (/^<(thead|tbody|tfoot|colgroup|caption)>/.test(html)) html = `<table>${html}</table>`;
+	switch (html) {
+		case "<table></table>":
+		case "<table><thead></thead></table>":
+		case "<table><tbody></tbody></table>":
+		case "<table><thead></thead><tbody></tbody></table>": return;
+	}
+	/** Parse HTML. `browser` is a string with the supposed resulting html of a real `innerHTML` call */
+	const browser = innerHTML(html);
+	if (html.toLowerCase() !== browser.toLowerCase()) return {
+		html,
+		browser
+	};
+}
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/postprocess.ts
+var postprocess_default = (path, state) => {
+	if (state.skip) return;
+	if (path.scope.data.events) path.node.body.push(t.expressionStatement(t.callExpression(registerImportMethod(path, "delegateEvents", getRendererConfig(path, "dom").moduleName), [t.arrayExpression(Array.from(path.scope.data.events).map((e) => t.stringLiteral(e)))])));
+	if (path.scope.data.templates?.length) {
+		if (path.hub.file.metadata.config.validate) for (const template$1 of path.scope.data.templates) {
+			const html = template$1.templateWithClosingTags;
+			if (typeof html === "string") {
+				const result = isInvalidMarkup(html);
+				if (result) {
+					console.warn("\nThe HTML provided is malformed and will yield unexpected output when evaluated by a browser.\n");
+					console.warn("User HTML:\n", result.html);
+					console.warn("Browser HTML:\n", result.browser);
+					console.warn("Original HTML:\n", html);
+				}
+			}
+		}
+		let domTemplates = path.scope.data.templates.filter((temp) => temp.renderer === "dom");
+		let ssrTemplates = path.scope.data.templates.filter((temp) => temp.renderer === "ssr");
+		domTemplates.length > 0 && appendTemplates(path, domTemplates);
+		ssrTemplates.length > 0 && appendTemplates$1(path, ssrTemplates);
+	}
+};
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/config.ts
+var config_default = {
+	moduleName: "dom",
+	generate: "dom",
+	hydratable: false,
+	delegateEvents: true,
+	delegatedEvents: [],
+	builtIns: [],
+	requireImportSource: false,
+	wrapConditionals: true,
+	omitNestedClosingTags: false,
+	omitLastClosingTag: true,
+	omitQuotes: true,
+	contextToCustomElements: false,
+	staticMarker: "@once",
+	effectWrapper: "effect",
+	memoWrapper: "memo",
+	validate: true
+};
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/shared/preprocess.ts
+var preprocess_default = (path, state) => {
+	const lib = (path.hub.file.metadata.config = Object.assign({}, config_default, state.opts)).requireImportSource;
+	if (lib) {
+		const comments = path.hub.file.ast.comments;
+		let process = false;
+		for (let i = 0; i < comments.length; i++) {
+			const pieces = comments[i].value.split("@jsxImportSource");
+			if (pieces.length === 2 && pieces[1].trim() === lib) {
+				process = true;
+				break;
+			}
+		}
+		if (!process) {
+			state.skip = true;
+			return;
+		}
+	}
+};
+
+//#endregion
+//#region src/babel-plugin-jsx-dom-expressions/babel-plugin-jsx-dom-expressions/index.ts
+const syntaxJSX = declare(() => {
+	return {
+		name: "syntax-jsx",
+		manipulateOptions(opts, parserOpts) {
+			if (parserOpts.plugins.some((p) => (Array.isArray(p) ? p[0] : p) === "typescript")) return;
+			parserOpts.plugins.push("jsx");
+		}
+	};
+});
+const jsxTransform = () => {
+	return {
+		name: "JSX DOM Expressions",
+		inherits: syntaxJSX,
+		visitor: {
+			JSXElement: transformJSX,
+			JSXFragment: transformJSX,
+			Program: {
+				enter: preprocess_default,
+				exit: postprocess_default
+			}
+		}
+	};
+};
+var babel_plugin_jsx_dom_expressions_default = jsxTransform;
+
+//#endregion
+//#region src/plugin-transform-typescript/enum.ts
+function isTransparentExprWrapper(node) {
+	return t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node) || t.isTSTypeAssertion(node) || t.isTSNonNullExpression(node) || t.isTypeCastExpression(node) || t.isParenthesizedExpression(node);
+}
+function skipTransparentExprWrapperNodes(node) {
+	while (isTransparentExprWrapper(node)) node = node.expression;
+	return node;
+}
+const PURE_ANNOTATION = "#__PURE__";
+const isPureAnnotated = ({ leadingComments }) => !!leadingComments && leadingComments.some((comment) => /[@#]__PURE__/.test(comment.value));
+function annotateAsPure(pathOrNode) {
+	const node = pathOrNode.node || pathOrNode;
+	if (isPureAnnotated(node)) return;
+	addComment(node, "leading", PURE_ANNOTATION);
+}
+const ENUMS = /* @__PURE__ */ new WeakMap();
+const buildEnumWrapper = template.expression(`
+    (function (ID) {
+      ASSIGNMENTS;
+      return ID;
+    })(INIT)
+  `);
+function transpileEnum(path, t$1) {
+	const { node, parentPath } = path;
+	if (node.declare) {
+		path.remove();
+		return;
+	}
+	const name = node.id.name;
+	const { fill, data, isPure } = enumFill(path, t$1, node.id);
+	switch (parentPath.type) {
+		case "BlockStatement":
+		case "ExportNamedDeclaration":
+		case "Program": {
+			const isGlobal = t$1.isProgram(path.parent);
+			const isSeen = seen(parentPath);
+			let init = t$1.objectExpression([]);
+			if (isSeen || isGlobal) init = t$1.logicalExpression("||", t$1.cloneNode(fill.ID), init);
+			const enumIIFE = buildEnumWrapper({
+				...fill,
+				INIT: init
+			});
+			if (isPure) annotateAsPure(enumIIFE);
+			if (isSeen) (parentPath.isExportDeclaration() ? parentPath : path).replaceWith(t$1.expressionStatement(t$1.assignmentExpression("=", t$1.cloneNode(node.id), enumIIFE)));
+			else path.scope.registerDeclaration(path.replaceWith(t$1.variableDeclaration(isGlobal ? "var" : "let", [t$1.variableDeclarator(node.id, enumIIFE)]))[0]);
+			ENUMS.set(path.scope.getBindingIdentifier(name), data);
+			break;
+		}
+		default: throw new Error(`Unexpected enum parent '${path.parent.type}`);
+	}
+	function seen(parentPath$1) {
+		if (parentPath$1.isExportDeclaration()) return seen(parentPath$1.parentPath);
+		if (parentPath$1.getData(name)) return true;
+		else {
+			parentPath$1.setData(name, true);
+			return false;
+		}
+	}
+}
+const buildStringAssignment = template.statement(`
+  ENUM["NAME"] = VALUE;
+`);
+const buildNumericAssignment = template.statement(`
+  ENUM[ENUM["NAME"] = VALUE] = "NAME";
+`);
+const buildEnumMember = (isString, options) => (isString ? buildStringAssignment : buildNumericAssignment)(options);
+/**
+* Generates the statement that fills in the variable declared by the enum.
+* `(function (E) { ... assignments ... })(E || (E = {}));`
+*/
+function enumFill(path, t$1, id) {
+	const { enumValues, data, isPure } = translateEnumValues(path, t$1);
+	const enumMembers = path.get("members");
+	const assignments = [];
+	for (let i = 0; i < enumMembers.length; i++) {
+		const [memberName, memberValue] = enumValues[i];
+		assignments.push(t$1.inheritsComments(buildEnumMember(isSyntacticallyString(memberValue), {
+			ENUM: t$1.cloneNode(id),
+			NAME: memberName,
+			VALUE: memberValue
+		}), enumMembers[i].node));
+	}
+	return {
+		fill: {
+			ID: t$1.cloneNode(id),
+			ASSIGNMENTS: assignments
+		},
+		data,
+		isPure
+	};
+}
+function isSyntacticallyString(expr) {
+	expr = skipTransparentExprWrapperNodes(expr);
+	switch (expr.type) {
+		case "BinaryExpression": {
+			const left = expr.left;
+			const right = expr.right;
+			return expr.operator === "+" && (isSyntacticallyString(left) || isSyntacticallyString(right));
+		}
+		case "TemplateLiteral":
+		case "StringLiteral": return true;
+	}
+	return false;
+}
+function ReferencedIdentifier(expr, state) {
+	const { seen, path, t: t$1 } = state;
+	const name = expr.node.name;
+	if (seen.has(name)) {
+		for (let curScope = expr.scope; curScope !== path.scope; curScope = curScope.parent) if (curScope.hasOwnBinding(name)) return;
+		expr.replaceWith(t$1.memberExpression(t$1.cloneNode(path.node.id), t$1.cloneNode(expr.node)));
+		expr.skip();
+	}
+}
+const enumSelfReferenceVisitor = { ReferencedIdentifier };
+function translateEnumValues(path, t$1) {
+	const bindingIdentifier = path.scope.getBindingIdentifier(path.node.id.name);
+	const seen = ENUMS.get(bindingIdentifier) ?? /* @__PURE__ */ new Map();
+	let constValue = -1;
+	let lastName;
+	let isPure = true;
+	const enumValues = path.get("members").map((memberPath) => {
+		const member = memberPath.node;
+		const name = t$1.isIdentifier(member.id) ? member.id.name : member.id.value;
+		const initializerPath = memberPath.get("initializer");
+		const initializer = member.initializer;
+		let value;
+		if (initializer) {
+			constValue = computeConstantValue(initializerPath, seen);
+			if (constValue !== void 0) {
+				seen.set(name, constValue);
+				assert(typeof constValue === "number" || typeof constValue === "string");
+				if (constValue === Infinity || Number.isNaN(constValue)) value = t$1.identifier(String(constValue));
+				else if (constValue === -Infinity) value = t$1.unaryExpression("-", t$1.identifier("Infinity"));
+				else value = t$1.valueToNode(constValue);
+			} else {
+				isPure &&= initializerPath.isPure();
+				if (initializerPath.isReferencedIdentifier()) ReferencedIdentifier(initializerPath, {
+					t: t$1,
+					seen,
+					path
+				});
+				else initializerPath.traverse(enumSelfReferenceVisitor, {
+					t: t$1,
+					seen,
+					path
+				});
+				value = initializerPath.node;
+				seen.set(name, void 0);
+			}
+		} else if (typeof constValue === "number") {
+			constValue += 1;
+			value = t$1.numericLiteral(constValue);
+			seen.set(name, constValue);
+		} else if (typeof constValue === "string") throw path.buildCodeFrameError("Enum member must have initializer.");
+		else {
+			const lastRef = t$1.memberExpression(t$1.cloneNode(path.node.id), t$1.stringLiteral(lastName), true);
+			value = t$1.binaryExpression("+", t$1.numericLiteral(1), lastRef);
+			seen.set(name, void 0);
+		}
+		lastName = name;
+		return [name, value];
+	});
+	return {
+		isPure,
+		data: seen,
+		enumValues
+	};
+}
+function computeConstantValue(path, prevMembers, seen = /* @__PURE__ */ new Set()) {
+	return evaluate(path);
+	function evaluate(path$1) {
+		const expr = path$1.node;
+		switch (expr.type) {
+			case "MemberExpression": return evaluateRef(path$1, prevMembers, seen);
+			case "StringLiteral": return expr.value;
+			case "UnaryExpression": return evalUnaryExpression(path$1);
+			case "BinaryExpression": return evalBinaryExpression(path$1);
+			case "NumericLiteral": return expr.value;
+			case "ParenthesizedExpression": return evaluate(path$1.get("expression"));
+			case "Identifier": return evaluateRef(path$1, prevMembers, seen);
+			case "TemplateLiteral": {
+				if (expr.quasis.length === 1) return expr.quasis[0].value.cooked;
+				const paths = path$1.get("expressions");
+				const quasis = expr.quasis;
+				let str = "";
+				for (let i = 0; i < quasis.length; i++) {
+					str += quasis[i].value.cooked;
+					if (i + 1 < quasis.length) {
+						const value = evaluateRef(paths[i], prevMembers, seen);
+						if (value === void 0) return void 0;
+						str += value;
+					}
+				}
+				return str;
+			}
+			default: return;
+		}
+	}
+	function evaluateRef(path$1, prevMembers$1, seen$1) {
+		if (path$1.isMemberExpression()) {
+			const expr = path$1.node;
+			const obj = expr.object;
+			const prop = expr.property;
+			if (!t.isIdentifier(obj) || (expr.computed ? !t.isStringLiteral(prop) : !t.isIdentifier(prop))) return;
+			const bindingIdentifier = path$1.scope.getBindingIdentifier(obj.name);
+			const data = ENUMS.get(bindingIdentifier);
+			if (!data) return;
+			return data.get(prop.computed ? prop.value : prop.name);
+		} else if (path$1.isIdentifier()) {
+			const name = path$1.node.name;
+			if (["Infinity", "NaN"].includes(name)) return Number(name);
+			let value = prevMembers$1?.get(name);
+			if (value !== void 0) return value;
+			if (prevMembers$1?.has(name)) return;
+			if (seen$1.has(path$1.node)) return;
+			seen$1.add(path$1.node);
+			value = computeConstantValue(path$1.resolve(), prevMembers$1, seen$1);
+			return value;
+		}
+	}
+	function evalUnaryExpression(path$1) {
+		const value = evaluate(path$1.get("argument"));
+		if (value === void 0) return;
+		switch (path$1.node.operator) {
+			case "+": return value;
+			case "-": return -value;
+			case "~": return ~value;
+			default: return;
+		}
+	}
+	function evalBinaryExpression(path$1) {
+		const left = evaluate(path$1.get("left"));
+		if (left === void 0) return;
+		const right = evaluate(path$1.get("right"));
+		if (right === void 0) return;
+		switch (path$1.node.operator) {
+			case "|": return left | right;
+			case "&": return left & right;
+			case ">>": return left >> right;
+			case ">>>": return left >>> right;
+			case "<<": return left << right;
+			case "^": return left ^ right;
+			case "*": return left * right;
+			case "/": return left / right;
+			case "+": return left + right;
+			case "-": return left - right;
+			case "%": return left % right;
+			case "**": return left ** right;
+			default: return;
+		}
+	}
+}
+
+//#endregion
+//#region src/plugin-transform-typescript/const-enum.ts
+const EXPORTED_CONST_ENUMS_IN_NAMESPACE = /* @__PURE__ */ new WeakSet();
+function transpileConstEnum(path, t$1) {
+	const { name } = path.node.id;
+	const parentIsExport = path.parentPath.isExportNamedDeclaration();
+	let isExported = parentIsExport;
+	if (!isExported && t$1.isProgram(path.parent)) isExported = path.parent.body.some((stmt) => t$1.isExportNamedDeclaration(stmt) && stmt.exportKind !== "type" && !stmt.source && stmt.specifiers.some((spec) => t$1.isExportSpecifier(spec) && spec.exportKind !== "type" && spec.local.name === name));
+	const { enumValues: entries } = translateEnumValues(path, t$1);
+	if (isExported || EXPORTED_CONST_ENUMS_IN_NAMESPACE.has(path.node)) {
+		const obj = t$1.objectExpression(entries.map(([name$1, value]) => t$1.objectProperty(t$1.isValidIdentifier(name$1) ? t$1.identifier(name$1) : t$1.stringLiteral(name$1), value)));
+		if (path.scope.hasOwnBinding(name)) (parentIsExport ? path.parentPath : path).replaceWith(t$1.expressionStatement(t$1.callExpression(t$1.memberExpression(t$1.identifier("Object"), t$1.identifier("assign")), [path.node.id, obj])));
+		else {
+			path.replaceWith(t$1.variableDeclaration("var", [t$1.variableDeclarator(path.node.id, obj)]));
+			path.scope.registerDeclaration(path);
+		}
+		return;
+	}
+	const entriesMap = new Map(entries);
+	path.scope.path.traverse({
+		Scope(path$1) {
+			if (path$1.scope.hasOwnBinding(name)) path$1.skip();
+		},
+		MemberExpression(path$1) {
+			if (!t$1.isIdentifier(path$1.node.object, { name })) return;
+			let key;
+			if (path$1.node.computed) if (t$1.isStringLiteral(path$1.node.property)) key = path$1.node.property.value;
+			else return;
+			else if (t$1.isIdentifier(path$1.node.property)) key = path$1.node.property.name;
+			else return;
+			if (!entriesMap.has(key)) return;
+			path$1.replaceWith(t$1.cloneNode(entriesMap.get(key)));
+		}
+	});
+	path.remove();
+}
+
+//#endregion
+//#region src/plugin-transform-typescript/create-class-features-plugin.ts
+const findBareSupers = visitors.environmentVisitor({ Super(path) {
+	const { node, parentPath } = path;
+	if (parentPath.isCallExpression({ callee: node })) this.push(parentPath);
+} });
+const referenceVisitor = {
+	"TSTypeAnnotation|TypeAnnotation"(path) {
+		path.skip();
+	},
+	ReferencedIdentifier(path, { scope }) {
+		if (scope.hasOwnBinding(path.node.name)) {
+			scope.rename(path.node.name);
+			path.skip();
+		}
+	}
+};
+function injectInitialization(path, constructor, nodes, renamer, lastReturnsThis) {
+	if (!nodes.length) return;
+	const isDerived = !!path.node.superClass;
+	if (!constructor) {
+		const newConstructor = t.classMethod("constructor", t.identifier("constructor"), [], t.blockStatement([]));
+		if (isDerived) {
+			newConstructor.params = [t.restElement(t.identifier("args"))];
+			newConstructor.body.body.push(template.statement.ast`super(...args)`);
+		}
+		[constructor] = path.get("body").unshiftContainer("body", newConstructor);
+	}
+	if (renamer) renamer(referenceVisitor, { scope: constructor.scope });
+	if (isDerived) {
+		const bareSupers = [];
+		constructor.traverse(findBareSupers, bareSupers);
+		let isFirst = true;
+		for (const bareSuper of bareSupers) {
+			if (isFirst) isFirst = false;
+			else nodes = nodes.map((n) => t.cloneNode(n));
+			if (!bareSuper.parentPath.isExpressionStatement()) {
+				const allNodes = [bareSuper.node, ...nodes.map((n) => t.toExpression(n))];
+				if (!lastReturnsThis) allNodes.push(t.thisExpression());
+				bareSuper.replaceWith(t.sequenceExpression(allNodes));
+			} else bareSuper.insertAfter(nodes);
+		}
+	} else constructor.get("body").unshiftContainer("body", nodes);
+}
+
+//#endregion
+//#region src/plugin-transform-typescript/global-types.ts
+const GLOBAL_TYPES = /* @__PURE__ */ new WeakMap();
+function isGlobalType({ scope }, name) {
+	if (scope.hasBinding(name)) return false;
+	if (GLOBAL_TYPES.get(scope).has(name)) return true;
+	console.warn(`The exported identifier "${name}" is not declared in Babel's scope tracker\nas a JavaScript value binding, and "@babel/plugin-transform-typescript"\nnever encountered it as a TypeScript type declaration.\nIt will be treated as a JavaScript value.\n\nThis problem is likely caused by another plugin injecting\n"${name}" without registering it in the scope tracker. If you are the author\n of that plugin, please use "scope.registerDeclaration(declarationPath)".`);
+	return false;
+}
+function registerGlobalType(programScope, name) {
+	GLOBAL_TYPES.get(programScope).add(name);
+}
+
+//#endregion
+//#region src/plugin-transform-typescript/namespace.ts
+function getFirstIdentifier(node) {
+	if (t.isIdentifier(node)) return node;
+	return getFirstIdentifier(node.left);
+}
+function transpileNamespace(path, allowNamespaces) {
+	if (path.node.declare || path.node.id.type === "StringLiteral") {
+		path.remove();
+		return;
+	}
+	if (!allowNamespaces) throw path.get("id").buildCodeFrameError("Namespace not marked type-only declare. Non-declarative namespaces are only supported experimentally in Babel. To enable and review caveats see: https://babeljs.io/docs/en/babel-plugin-transform-typescript");
+	const name = getFirstIdentifier(path.node.id).name;
+	const value = handleNested(path, path.node);
+	if (value === null) {
+		registerGlobalType(path.findParent((p) => p.isProgram()).scope, name);
+		path.remove();
+	} else if (path.scope.hasOwnBinding(name)) path.replaceWith(value);
+	else path.scope.registerDeclaration(path.replaceWithMultiple([getDeclaration(name), value])[0]);
+}
+function getDeclaration(name) {
+	return t.variableDeclaration("let", [t.variableDeclarator(t.identifier(name))]);
+}
+function getMemberExpression(name, itemName) {
+	return t.memberExpression(t.identifier(name), t.identifier(itemName));
+}
+/**
+* Convert export const foo = 1 to Namespace.foo = 1;
+*
+* @param {t.VariableDeclaration} node given variable declaration, e.g. `const foo = 1`
+* @param {string} name the generated unique namespace member name
+* @param {*} hub An instance implements HubInterface defined in `@babel/traverse` that can throw a code frame error
+*/
+function handleVariableDeclaration(node, name, hub) {
+	if (node.kind !== "const") throw hub.file.buildCodeFrameError(node, "Namespaces exporting non-const are not supported by Babel. Change to const or see: https://babeljs.io/docs/en/babel-plugin-transform-typescript");
+	const { declarations } = node;
+	if (declarations.every((declarator) => t.isIdentifier(declarator.id))) {
+		for (const declarator of declarations) declarator.init = t.assignmentExpression("=", getMemberExpression(name, declarator.id.name), declarator.init);
+		return [node];
+	}
+	const bindingIdentifiers = t.getBindingIdentifiers(node);
+	const assignments = [];
+	for (const idName in bindingIdentifiers) assignments.push(t.assignmentExpression("=", getMemberExpression(name, idName), t.cloneNode(bindingIdentifiers[idName])));
+	return [node, t.expressionStatement(t.sequenceExpression(assignments))];
+}
+function buildNestedAmbientModuleError(path, node) {
+	return path.hub.buildError(node, "Ambient modules cannot be nested in other modules or namespaces.", Error);
+}
+function handleNested(path, node, parentExport) {
+	const names = /* @__PURE__ */ new Set();
+	const realName = node.id;
+	const name = path.scope.generateUid(realName.name);
+	const body = node.body;
+	let namespaceTopLevel;
+	namespaceTopLevel = t.isTSModuleBlock(body) ? body.body : [t.exportNamedDeclaration(body)];
+	let isEmpty = true;
+	for (let i = 0; i < namespaceTopLevel.length; i++) {
+		const subNode = namespaceTopLevel[i];
+		switch (subNode.type) {
+			case "TSModuleDeclaration": {
+				if (!t.isIdentifier(subNode.id)) throw buildNestedAmbientModuleError(path, subNode);
+				const transformed = handleNested(path, subNode);
+				if (transformed !== null) {
+					isEmpty = false;
+					const moduleName = subNode.id.name;
+					if (names.has(moduleName)) namespaceTopLevel[i] = transformed;
+					else {
+						names.add(moduleName);
+						namespaceTopLevel.splice(i++, 1, getDeclaration(moduleName), transformed);
+					}
+				}
+				continue;
+			}
+			case "TSEnumDeclaration":
+			case "FunctionDeclaration":
+			case "ClassDeclaration":
+				isEmpty = false;
+				names.add(subNode.id.name);
+				continue;
+			case "VariableDeclaration":
+				isEmpty = false;
+				for (const name$1 in t.getBindingIdentifiers(subNode)) names.add(name$1);
+				continue;
+			default:
+				isEmpty &&= t.isTypeScript(subNode);
+				continue;
+			case "ExportNamedDeclaration":
+		}
+		if ("declare" in subNode.declaration && subNode.declaration.declare) continue;
+		switch (subNode.declaration.type) {
+			case "TSEnumDeclaration": EXPORTED_CONST_ENUMS_IN_NAMESPACE.add(subNode.declaration);
+			case "FunctionDeclaration":
+			case "ClassDeclaration": {
+				isEmpty = false;
+				const itemName = subNode.declaration.id.name;
+				names.add(itemName);
+				namespaceTopLevel.splice(i++, 1, subNode.declaration, t.expressionStatement(t.assignmentExpression("=", getMemberExpression(name, itemName), t.identifier(itemName))));
+				break;
+			}
+			case "VariableDeclaration": {
+				isEmpty = false;
+				const nodes = handleVariableDeclaration(subNode.declaration, name, path.hub);
+				namespaceTopLevel.splice(i, nodes.length, ...nodes);
+				i += nodes.length - 1;
+				break;
+			}
+			case "TSModuleDeclaration": {
+				if (!t.isIdentifier(subNode.declaration.id)) throw buildNestedAmbientModuleError(path, subNode.declaration);
+				const transformed = handleNested(path, subNode.declaration, t.identifier(name));
+				if (transformed !== null) {
+					isEmpty = false;
+					const moduleName = subNode.declaration.id.name;
+					if (names.has(moduleName)) namespaceTopLevel[i] = transformed;
+					else {
+						names.add(moduleName);
+						namespaceTopLevel.splice(i++, 1, getDeclaration(moduleName), transformed);
+					}
+				} else {
+					namespaceTopLevel.splice(i, 1);
+					i--;
+				}
+			}
+		}
+	}
+	if (isEmpty) return null;
+	let fallthroughValue = t.objectExpression([]);
+	if (parentExport) {
+		const memberExpr = t.memberExpression(parentExport, realName);
+		fallthroughValue = template.expression.ast`
+      ${t.cloneNode(memberExpr)} ||
+        (${t.cloneNode(memberExpr)} = ${fallthroughValue})
+    `;
+	}
+	return template.statement.ast`
+    (function (${t.identifier(name)}) {
+      ${namespaceTopLevel}
+    })(${realName} || (${t.cloneNode(realName)} = ${fallthroughValue}));
+  `;
+}
+
+//#endregion
+//#region src/plugin-transform-typescript/plugin-syntax-typescript.ts
+var removePlugin = function(plugins, name) {
+	const indices = [];
+	plugins.forEach((plugin, i) => {
+		if ((Array.isArray(plugin) ? plugin[0] : plugin) === name) indices.unshift(i);
+	});
+	for (const i of indices) plugins.splice(i, 1);
+};
+const syntaxTypeScript = declare((api, opts) => {
+	const { disallowAmbiguousJSXLike, dts } = opts;
+	var { isTSX } = opts;
+	return {
+		name: "syntax-typescript",
+		manipulateOptions(opts$1, parserOpts) {
+			{
+				const { plugins } = parserOpts;
+				removePlugin(plugins, "flow");
+				removePlugin(plugins, "jsx");
+				plugins.push("objectRestSpread", "classProperties");
+				if (isTSX) plugins.push("jsx");
+			}
+			parserOpts.plugins.push(["typescript", {
+				disallowAmbiguousJSXLike,
+				dts
+			}]);
+		}
+	};
+});
+var plugin_syntax_typescript_default = syntaxTypeScript;
+
+//#endregion
+//#region src/plugin-transform-typescript/index.ts
+function isInType(path) {
+	switch (path.parent.type) {
+		case "TSTypeReference":
+		case "TSExpressionWithTypeArguments":
+		case "TSExpressionWithTypeArguments":
+		case "TSTypeQuery": return true;
+		case "TSQualifiedName": return path.parentPath.findParent((path$1) => path$1.type !== "TSQualifiedName").type !== "TSImportEqualsDeclaration";
+		case "ExportSpecifier": return path.parent.exportKind === "type" || path.parentPath.parent.exportKind === "type";
+		default: return false;
+	}
+}
+const NEEDS_EXPLICIT_ESM = /* @__PURE__ */ new WeakMap();
+const PARSED_PARAMS = /* @__PURE__ */ new WeakSet();
+function safeRemove(path) {
+	const ids = path.getBindingIdentifiers();
+	for (const name of Object.keys(ids)) {
+		const binding = path.scope.getBinding(name);
+		if (binding && binding.identifier === ids[name]) binding.scope.removeBinding(name);
+	}
+	path.opts.noScope = true;
+	path.remove();
+	path.opts.noScope = false;
+}
+function assertCjsTransformEnabled(path, pass, wrong, suggestion, extra = "") {
+	if (pass.file.get("@babel/plugin-transform-modules-*") !== "commonjs") throw path.buildCodeFrameError(`\`${wrong}\` is only supported when compiling modules to CommonJS.\nPlease consider using \`${suggestion}\`${extra}, or add @babel/plugin-transform-modules-commonjs to your Babel config.`);
+}
+const pluginTransformTypescript = declare((api, opts) => {
+	const { types: t$1, template: template$1 } = api;
+	const JSX_PRAGMA_REGEX = /\*?\s*@jsx((?:Frag)?)\s+(\S+)/;
+	const { allowNamespaces = true, jsxPragma = "React.createElement", jsxPragmaFrag = "React.Fragment", onlyRemoveTypeImports = false, optimizeConstEnums = false } = opts;
+	var { allowDeclareFields = false } = opts;
+	const classMemberVisitors = {
+		field(path) {
+			const { node } = path;
+			if (!allowDeclareFields && node.declare) throw path.buildCodeFrameError("The 'declare' modifier is only allowed when the 'allowDeclareFields' option of @babel/plugin-transform-typescript or @babel/preset-typescript is enabled.");
+			if (node.declare) {
+				if (node.value) throw path.buildCodeFrameError(`Fields with the 'declare' modifier cannot be initialized here, but only in the constructor`);
+				if (!node.decorators) path.remove();
+			} else if (node.definite) {
+				if (node.value) throw path.buildCodeFrameError(`Definitely assigned fields cannot be initialized here, but only in the constructor`);
+				if (!allowDeclareFields && !node.decorators && !t$1.isClassPrivateProperty(node)) path.remove();
+			} else if (node.abstract) path.remove();
+			else if (!allowDeclareFields && !node.value && !node.decorators && !t$1.isClassPrivateProperty(node)) path.remove();
+			if (node.accessibility) node.accessibility = null;
+			if (node.abstract) node.abstract = null;
+			if (node.readonly) node.readonly = null;
+			if (node.optional) node.optional = null;
+			if (node.typeAnnotation) node.typeAnnotation = null;
+			if (node.definite) node.definite = null;
+			if (node.declare) node.declare = null;
+			if (node.override) node.override = null;
+		},
+		method({ node }) {
+			if (node.accessibility) node.accessibility = null;
+			if (node.abstract) node.abstract = null;
+			if (node.optional) node.optional = null;
+			if (node.override) node.override = null;
+		},
+		constructor(path, classPath) {
+			if (path.node.accessibility) path.node.accessibility = null;
+			const assigns = [];
+			const { scope } = path;
+			for (const paramPath of path.get("params")) {
+				const param = paramPath.node;
+				if (param.type === "TSParameterProperty") {
+					const parameter = param.parameter;
+					if (PARSED_PARAMS.has(parameter)) continue;
+					PARSED_PARAMS.add(parameter);
+					let id;
+					if (t$1.isIdentifier(parameter)) id = parameter;
+					else if (t$1.isAssignmentPattern(parameter) && t$1.isIdentifier(parameter.left)) id = parameter.left;
+					else throw paramPath.buildCodeFrameError("Parameter properties can not be destructuring patterns.");
+					assigns.push(template$1.statement.ast`
+              this.${t$1.cloneNode(id)} = ${t$1.cloneNode(id)}
+            `);
+					paramPath.replaceWith(paramPath.get("parameter"));
+					scope.registerBinding("param", paramPath);
+				}
+			}
+			injectInitialization(classPath, path, assigns);
+		}
+	};
+	return {
+		name: "transform-typescript",
+		inherits: plugin_syntax_typescript_default,
+		visitor: {
+			Pattern: visitPattern,
+			Identifier: visitPattern,
+			RestElement: visitPattern,
+			Program: {
+				enter(path, state) {
+					const { file } = state;
+					let fileJsxPragma = null;
+					let fileJsxPragmaFrag = null;
+					const programScope = path.scope;
+					if (!GLOBAL_TYPES.has(programScope)) GLOBAL_TYPES.set(programScope, /* @__PURE__ */ new Set());
+					if (file.ast.comments) for (const comment of file.ast.comments) {
+						const jsxMatches = JSX_PRAGMA_REGEX.exec(comment.value);
+						if (jsxMatches) if (jsxMatches[1]) fileJsxPragmaFrag = jsxMatches[2];
+						else fileJsxPragma = jsxMatches[2];
+					}
+					let pragmaImportName = fileJsxPragma || jsxPragma;
+					if (pragmaImportName) [pragmaImportName] = pragmaImportName.split(".");
+					let pragmaFragImportName = fileJsxPragmaFrag || jsxPragmaFrag;
+					if (pragmaFragImportName) [pragmaFragImportName] = pragmaFragImportName.split(".");
+					for (let stmt of path.get("body")) {
+						if (stmt.isImportDeclaration()) {
+							if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
+							if (stmt.node.importKind === "type") {
+								for (const specifier of stmt.node.specifiers) registerGlobalType(programScope, specifier.local.name);
+								stmt.remove();
+								continue;
+							}
+							const importsToRemove = /* @__PURE__ */ new Set();
+							const specifiersLength = stmt.node.specifiers.length;
+							const isAllSpecifiersElided = () => specifiersLength > 0 && specifiersLength === importsToRemove.size;
+							for (const specifier of stmt.node.specifiers) if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") {
+								registerGlobalType(programScope, specifier.local.name);
+								const binding = stmt.scope.getBinding(specifier.local.name);
+								if (binding) importsToRemove.add(binding.path);
+							}
+							if (onlyRemoveTypeImports) NEEDS_EXPLICIT_ESM.set(path.node, false);
+							else {
+								if (stmt.node.specifiers.length === 0) {
+									NEEDS_EXPLICIT_ESM.set(path.node, false);
+									continue;
+								}
+								for (const specifier of stmt.node.specifiers) {
+									const binding = stmt.scope.getBinding(specifier.local.name);
+									if (binding && !importsToRemove.has(binding.path)) if (isImportTypeOnly({
+										binding,
+										programPath: path,
+										pragmaImportName,
+										pragmaFragImportName
+									})) importsToRemove.add(binding.path);
+									else NEEDS_EXPLICIT_ESM.set(path.node, false);
+								}
+							}
+							if (isAllSpecifiersElided() && !onlyRemoveTypeImports) stmt.remove();
+							else for (const importPath of importsToRemove) importPath.remove();
+							continue;
+						}
+						if (!onlyRemoveTypeImports && stmt.isTSImportEqualsDeclaration()) {
+							const { id } = stmt.node;
+							const binding = stmt.scope.getBinding(id.name);
+							if (binding && !stmt.node.isExport && isImportTypeOnly({
+								binding,
+								programPath: path,
+								pragmaImportName,
+								pragmaFragImportName
+							})) {
+								stmt.remove();
+								continue;
+							}
+						}
+						if (stmt.isExportDeclaration()) stmt = stmt.get("declaration");
+						if (stmt.isVariableDeclaration({ declare: true })) for (const name of Object.keys(stmt.getBindingIdentifiers())) registerGlobalType(programScope, name);
+						else if (stmt.isTSTypeAliasDeclaration() || stmt.isTSDeclareFunction() && stmt.get("id").isIdentifier() || stmt.isTSInterfaceDeclaration() || stmt.isClassDeclaration({ declare: true }) || stmt.isTSEnumDeclaration({ declare: true }) || stmt.isTSModuleDeclaration({ declare: true }) && stmt.get("id").isIdentifier()) registerGlobalType(programScope, stmt.node.id.name);
+					}
+				},
+				exit(path) {
+					if (path.node.sourceType === "module" && NEEDS_EXPLICIT_ESM.get(path.node)) path.pushContainer("body", t$1.exportNamedDeclaration());
+				}
+			},
+			ExportNamedDeclaration(path, state) {
+				if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
+				if (path.node.exportKind === "type") {
+					path.remove();
+					return;
+				}
+				if (path.node.source && path.node.specifiers.length > 0 && path.node.specifiers.every((specifier) => specifier.type === "ExportSpecifier" && specifier.exportKind === "type")) {
+					path.remove();
+					return;
+				}
+				if (!path.node.source && path.node.specifiers.length > 0 && path.node.specifiers.every((specifier) => t$1.isExportSpecifier(specifier) && isGlobalType(path, specifier.local.name))) {
+					path.remove();
+					return;
+				}
+				if (t$1.isTSModuleDeclaration(path.node.declaration)) {
+					const namespace = path.node.declaration;
+					if (!t$1.isStringLiteral(namespace.id)) {
+						const id = getFirstIdentifier(namespace.id);
+						if (path.scope.hasOwnBinding(id.name)) path.replaceWith(namespace);
+						else {
+							const [newExport] = path.replaceWithMultiple([t$1.exportNamedDeclaration(t$1.variableDeclaration("let", [t$1.variableDeclarator(t$1.cloneNode(id))])), namespace]);
+							path.scope.registerDeclaration(newExport);
+						}
+					}
+				}
+				NEEDS_EXPLICIT_ESM.set(state.file.ast.program, false);
+			},
+			ExportAllDeclaration(path) {
+				if (path.node.exportKind === "type") path.remove();
+			},
+			ExportSpecifier(path) {
+				if (!path.parent.source && isGlobalType(path, path.node.local.name) || path.node.exportKind === "type") path.remove();
+			},
+			ExportDefaultDeclaration(path, state) {
+				if (!NEEDS_EXPLICIT_ESM.has(state.file.ast.program)) NEEDS_EXPLICIT_ESM.set(state.file.ast.program, true);
+				if (t$1.isIdentifier(path.node.declaration) && isGlobalType(path, path.node.declaration.name)) {
+					path.remove();
+					return;
+				}
+				NEEDS_EXPLICIT_ESM.set(state.file.ast.program, false);
+			},
+			TSDeclareFunction(path) {
+				safeRemove(path);
+			},
+			TSDeclareMethod(path) {
+				safeRemove(path);
+			},
+			VariableDeclaration(path) {
+				if (path.node.declare) safeRemove(path);
+			},
+			VariableDeclarator({ node }) {
+				if (node.definite) node.definite = null;
+			},
+			TSIndexSignature(path) {
+				path.remove();
+			},
+			ClassDeclaration(path) {
+				const { node } = path;
+				if (node.declare) safeRemove(path);
+			},
+			Class(path) {
+				const { node } = path;
+				if (node.typeParameters) node.typeParameters = null;
+				if (node.superTypeParameters) node.superTypeParameters = null;
+				if (node.implements) node.implements = null;
+				if (node.abstract) node.abstract = null;
+				path.get("body.body").forEach((child) => {
+					if (child.isClassMethod() || child.isClassPrivateMethod()) if (child.node.kind === "constructor") classMemberVisitors.constructor(child, path);
+					else classMemberVisitors.method(child);
+					else if (child.isClassProperty() || child.isClassPrivateProperty() || child.isClassAccessorProperty()) classMemberVisitors.field(child);
+				});
+			},
+			Function(path) {
+				const { node } = path;
+				if (node.typeParameters) node.typeParameters = null;
+				if (node.returnType) node.returnType = null;
+				const params = node.params;
+				if (params.length > 0 && t$1.isIdentifier(params[0], { name: "this" })) params.shift();
+			},
+			TSModuleDeclaration(path) {
+				transpileNamespace(path, allowNamespaces);
+			},
+			TSInterfaceDeclaration(path) {
+				path.remove();
+			},
+			TSTypeAliasDeclaration(path) {
+				path.remove();
+			},
+			TSEnumDeclaration(path) {
+				if (optimizeConstEnums && path.node.const) transpileConstEnum(path, t$1);
+				else transpileEnum(path, t$1);
+			},
+			TSImportEqualsDeclaration(path, pass) {
+				const { id, moduleReference } = path.node;
+				let init;
+				let varKind;
+				if (t$1.isTSExternalModuleReference(moduleReference)) {
+					assertCjsTransformEnabled(path, pass, `import ${id.name} = require(...);`, `import ${id.name} from '...';`, " alongside Typescript's --allowSyntheticDefaultImports option");
+					init = t$1.callExpression(t$1.identifier("require"), [moduleReference.expression]);
+					varKind = "const";
+				} else {
+					init = entityNameToExpr(moduleReference);
+					varKind = "var";
+				}
+				const newNode = t$1.variableDeclaration(varKind, [t$1.variableDeclarator(id, init)]);
+				path.replaceWith(path.node.isExport ? t$1.exportNamedDeclaration(newNode) : newNode);
+				path.scope.registerDeclaration(path);
+			},
+			TSExportAssignment(path, pass) {
+				assertCjsTransformEnabled(path, pass, `export = <value>;`, `export default <value>;`);
+				path.replaceWith(template$1.statement.ast`module.exports = ${path.node.expression}`);
+			},
+			TSTypeAssertion(path) {
+				path.replaceWith(path.node.expression);
+			},
+			[`TSAsExpression${t$1.tsSatisfiesExpression ? "|TSSatisfiesExpression" : ""}`](path) {
+				let { node } = path;
+				do
+					node = node.expression;
+				while (t$1.isTSAsExpression(node) || t$1.isTSSatisfiesExpression?.(node));
+				path.replaceWith(node);
+			},
+			[api.types.tsInstantiationExpression ? "TSNonNullExpression|TSInstantiationExpression" : "TSNonNullExpression"](path) {
+				path.replaceWith(path.node.expression);
+			},
+			CallExpression(path) {
+				path.node.typeParameters = null;
+			},
+			OptionalCallExpression(path) {
+				path.node.typeParameters = null;
+			},
+			NewExpression(path) {
+				path.node.typeParameters = null;
+			},
+			JSXOpeningElement(path) {
+				path.node.typeParameters = null;
+			},
+			TaggedTemplateExpression(path) {
+				path.node.typeParameters = null;
+			}
+		}
+	};
+	function entityNameToExpr(node) {
+		if (t$1.isTSQualifiedName(node)) return t$1.memberExpression(entityNameToExpr(node.left), node.right);
+		return node;
+	}
+	function visitPattern({ node }) {
+		if (node.typeAnnotation) node.typeAnnotation = null;
+		if (t$1.isIdentifier(node) && node.optional) node.optional = null;
+	}
+	function isImportTypeOnly({ binding, programPath, pragmaImportName, pragmaFragImportName }) {
+		for (const path of binding.referencePaths) if (!isInType(path)) return false;
+		if (binding.identifier.name !== pragmaImportName && binding.identifier.name !== pragmaFragImportName) return true;
+		let sourceFileHasJsx = false;
+		programPath.traverse({ "JSXElement|JSXFragment"(path) {
+			sourceFileHasJsx = true;
+			path.stop();
+		} });
+		return !sourceFileHasJsx;
+	}
+});
+var plugin_transform_typescript_default = pluginTransformTypescript;
+
+//#endregion
+//#region src/preset-typescript/normalize-options.ts
+const v = new OptionValidator("preset-typescript");
+function normalizeOptions(options = {}) {
+	const { allowNamespaces = true, jsxPragma, onlyRemoveTypeImports } = options;
+	const TopLevelOptions = {
+		ignoreExtensions: "ignoreExtensions",
+		allowNamespaces: "allowNamespaces",
+		disallowAmbiguousJSXLike: "disallowAmbiguousJSXLike",
+		jsxPragma: "jsxPragma",
+		jsxPragmaFrag: "jsxPragmaFrag",
+		onlyRemoveTypeImports: "onlyRemoveTypeImports",
+		optimizeConstEnums: "optimizeConstEnums",
+		rewriteImportExtensions: "rewriteImportExtensions",
+		allExtensions: "allExtensions",
+		isTSX: "isTSX"
+	};
+	const jsxPragmaFrag = v.validateStringOption(TopLevelOptions.jsxPragmaFrag, options.jsxPragmaFrag, "React.Fragment");
+	const allExtensions = v.validateBooleanOption(TopLevelOptions.allExtensions, options.allExtensions, false);
+	const isTSX = v.validateBooleanOption(TopLevelOptions.isTSX, options.isTSX, false);
+	if (isTSX) v.invariant(allExtensions, "isTSX:true requires allExtensions:true");
+	const ignoreExtensions = v.validateBooleanOption(TopLevelOptions.ignoreExtensions, options.ignoreExtensions, false);
+	const disallowAmbiguousJSXLike = v.validateBooleanOption(TopLevelOptions.disallowAmbiguousJSXLike, options.disallowAmbiguousJSXLike, false);
+	if (disallowAmbiguousJSXLike) v.invariant(allExtensions, "disallowAmbiguousJSXLike:true requires allExtensions:true");
+	return {
+		ignoreExtensions,
+		allowNamespaces,
+		disallowAmbiguousJSXLike,
+		jsxPragma,
+		jsxPragmaFrag,
+		onlyRemoveTypeImports,
+		optimizeConstEnums: v.validateBooleanOption(TopLevelOptions.optimizeConstEnums, options.optimizeConstEnums, false),
+		rewriteImportExtensions: v.validateBooleanOption(TopLevelOptions.rewriteImportExtensions, options.rewriteImportExtensions, false),
+		allExtensions,
+		isTSX
+	};
+}
+
+//#endregion
+//#region src/preset-typescript/plugin-rewrite-ts-imports.ts
+const pluginRewriteTSImports = declare(({ types: t$1, template: template$1 }) => {
+	function maybeReplace(source, path, state) {
+		if (!source) return;
+		if (t$1.isStringLiteral(source)) {
+			if (/^\.\.?\//.test(source.value)) source.value = source.value.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+)?)\.([cm]?)ts$/i, (m, tsx, d, ext, cm) => tsx ? ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js");
+			return;
+		}
+		if (state.availableHelper("tsRewriteRelativeImportExtensions")) path.replaceWith(t$1.callExpression(state.addHelper("tsRewriteRelativeImportExtensions"), [source]));
+		else path.replaceWith(template$1.expression.ast`(${source} + "").replace(/([\\/].*\.[mc]?)tsx?$/, "$1js")`);
+	}
+	return {
+		name: "preset-typescript/plugin-rewrite-ts-imports",
+		visitor: {
+			"ImportDeclaration|ExportAllDeclaration|ExportNamedDeclaration"(path, state) {
+				const node = path.node;
+				if ((t$1.isImportDeclaration(node) ? node.importKind : node.exportKind) === "value") maybeReplace(node.source, path.get("source"), state);
+			},
+			CallExpression(path, state) {
+				if (t$1.isImport(path.node.callee)) maybeReplace(path.node.arguments[0], path.get("arguments.0"), state);
+			},
+			ImportExpression(path, state) {
+				maybeReplace(path.node.source, path.get("source"), state);
+			}
+		}
+	};
+});
+var plugin_rewrite_ts_imports_default = pluginRewriteTSImports;
+
+//#endregion
+//#region src/preset-typescript/index.ts
+const presetTypescript = declarePreset((api, opts) => {
+	const { allExtensions, ignoreExtensions, allowNamespaces, disallowAmbiguousJSXLike, isTSX, jsxPragma, jsxPragmaFrag, onlyRemoveTypeImports, optimizeConstEnums, rewriteImportExtensions } = normalizeOptions(opts);
+	const pluginOptions = (disallowAmbiguousJSXLike$1) => ({
+		allowDeclareFields: opts.allowDeclareFields,
+		allowNamespaces,
+		disallowAmbiguousJSXLike: disallowAmbiguousJSXLike$1,
+		jsxPragma,
+		jsxPragmaFrag,
+		onlyRemoveTypeImports,
+		optimizeConstEnums
+	});
+	const getPlugins = (isTSX$1, disallowAmbiguousJSXLike$1) => {
+		return [[plugin_transform_typescript_default, {
+			isTSX: isTSX$1,
+			...pluginOptions(disallowAmbiguousJSXLike$1)
+		}]];
+	};
+	return {
+		plugins: rewriteImportExtensions ? [plugin_rewrite_ts_imports_default] : [],
+		overrides: allExtensions || ignoreExtensions ? [{ plugins: getPlugins(isTSX, disallowAmbiguousJSXLike) }] : [
+			{
+				test: /\.ts$/,
+				plugins: getPlugins(false, false)
+			},
+			{
+				test: /\.mts$/,
+				sourceType: "module",
+				plugins: getPlugins(false, true)
+			},
+			{
+				test: /\.cts$/,
+				sourceType: "unambiguous",
+				plugins: [[plugin_transform_typescript_default, pluginOptions(true)]]
+			},
+			{
+				test: /\.tsx$/,
+				plugins: getPlugins(true, false)
+			}
+		]
+	};
+});
+var preset_typescript_default = presetTypescript;
+
+//#endregion
+//#region src/index.ts
+function solidPreset(_context, options = {}) {
+	return { plugins: [[babel_plugin_jsx_dom_expressions_default, Object.assign({
+		moduleName: "solid-js/web",
+		builtIns: [
+			"For",
+			"Show",
+			"Switch",
+			"Match",
+			"Suspense",
+			"SuspenseList",
+			"Portal",
+			"Index",
+			"Dynamic",
+			"ErrorBoundary"
+		],
+		contextToCustomElements: true,
+		wrapConditionals: true,
+		generate: "dom"
+	}, options)]] };
+}
+const rolldownPluginSolid = (options) => {
+	if (options?.solid?.generate === "universal") {
+		if (!options?.solid?.moduleName) throw new Error("Universal mode requires a 'moduleName' option pointing to your custom renderer.\n\nPlease provide a moduleName that exports the required universal renderer functions:\n- createElement\n- createTextNode\n- insertNode\n- setProp\n- insert\n- spread\n- mergeProps\n- effect\n- memo\n- use\n\nExample configuration:\n{ solid: { generate: \"universal\", moduleName: \"my-custom-renderer\" } }\n\nYour custom renderer should be created using 'createRenderer' from 'solid-js/universal'.");
+	}
+	return {
+		name: "rolldown-plugin-solid",
+		transform: {
+			filter: { id: /\.(t|j)sx$/ },
+			async handler(code, id) {
+				const { name, ext } = parse(id);
+				const filename = name + ext;
+				const result = await transformAsync(code, {
+					presets: [[solidPreset, options?.solid ?? {}], [preset_typescript_default, options?.typescript ?? {}]],
+					filename,
+					sourceMaps: "inline"
+				});
+				if (result?.code === void 0 || result.code === null) throw new Error("No result was provided from Babel");
+				return result.code;
+			}
+		}
+	};
+};
+var src_default = rolldownPluginSolid;
+
+//#endregion
+export { src_default as default };