@zessjs/compiler 1.0.0

package/dist/compiler.js

@@ -0,0 +1,1348 @@
+import { generate } from "astring";
+import { decodeHTML } from "entities";
+import merge from "merge-source-map";
+import { parse } from "meriyah";
+import { SourceMapGenerator } from "source-map";
+
+//#region src/visit.ts
+const ESTreeNodeKeys = {
+	AccessorProperty: [
+		"key",
+		"value",
+		"$decorators"
+	],
+	ArrayExpression: ["$elements"],
+	ArrayPattern: ["$elements"],
+	ArrowFunctionExpression: ["$params", "body"],
+	AssignmentExpression: ["left", "right"],
+	AssignmentPattern: ["left", "right"],
+	AwaitExpression: ["argument"],
+	BinaryExpression: ["left", "right"],
+	BlockStatement: ["$body"],
+	BreakStatement: ["label"],
+	CallExpression: ["callee", "$arguments"],
+	ChainExpression: ["expression"],
+	ImportExpression: ["source", "options"],
+	CatchClause: ["param", "body"],
+	ClassBody: ["$body"],
+	ClassDeclaration: [
+		"id",
+		"body",
+		"superClass",
+		"$decorators"
+	],
+	ClassExpression: [
+		"id",
+		"body",
+		"superClass",
+		"$decorators"
+	],
+	ConditionalExpression: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	ContinueStatement: ["label"],
+	Decorator: ["expression"],
+	DoWhileStatement: ["test", "body"],
+	ExportAllDeclaration: [
+		"source",
+		"exported",
+		"$attributes"
+	],
+	ExportDefaultDeclaration: ["declaration"],
+	ExportNamedDeclaration: [
+		"declaration",
+		"$specifiers",
+		"source",
+		"$attributes"
+	],
+	ExportSpecifier: ["local", "exported"],
+	ExpressionStatement: ["expression"],
+	PropertyDefinition: [
+		"key",
+		"value",
+		"$decorators"
+	],
+	ForInStatement: [
+		"left",
+		"right",
+		"body"
+	],
+	ForOfStatement: [
+		"left",
+		"right",
+		"body"
+	],
+	ForStatement: [
+		"init",
+		"test",
+		"update",
+		"body"
+	],
+	FunctionDeclaration: [
+		"id",
+		"$params",
+		"body"
+	],
+	FunctionExpression: [
+		"id",
+		"$params",
+		"body"
+	],
+	IfStatement: [
+		"test",
+		"consequent",
+		"alternate"
+	],
+	ImportDeclaration: [
+		"source",
+		"$specifiers",
+		"$attributes"
+	],
+	ImportDefaultSpecifier: ["local"],
+	ImportAttribute: ["key", "value"],
+	ImportNamespaceSpecifier: ["local"],
+	ImportSpecifier: ["local", "imported"],
+	JSXNamespacedName: ["namespace", "name"],
+	JSXAttribute: ["name", "value"],
+	JSXClosingElement: ["name"],
+	JSXElement: [
+		"openingElement",
+		"closingElement",
+		"$children"
+	],
+	JSXExpressionContainer: ["expression"],
+	JSXFragment: [
+		"openingFragment",
+		"closingFragment",
+		"$children"
+	],
+	JSXOpeningElement: ["name", "$attributes"],
+	JSXSpreadAttribute: ["argument"],
+	JSXSpreadChild: ["expression"],
+	JSXMemberExpression: ["object", "property"],
+	LabeledStatement: ["label", "body"],
+	LogicalExpression: ["left", "right"],
+	MemberExpression: ["object", "property"],
+	MetaProperty: ["meta", "property"],
+	MethodDefinition: [
+		"key",
+		"value",
+		"$decorators"
+	],
+	NewExpression: ["callee", "$arguments"],
+	ObjectExpression: ["$properties"],
+	ObjectPattern: ["$properties"],
+	ParenthesizedExpression: ["expression"],
+	Program: ["$body"],
+	Property: ["key", "value"],
+	RestElement: ["argument", "value"],
+	ReturnStatement: ["argument"],
+	SequenceExpression: ["$expressions"],
+	SpreadElement: ["argument"],
+	StaticBlock: ["$body"],
+	SwitchCase: ["test", "$consequent"],
+	SwitchStatement: ["discriminant", "$cases"],
+	TaggedTemplateExpression: ["tag", "quasi"],
+	TemplateLiteral: ["$quasis", "$expressions"],
+	ThrowStatement: ["argument"],
+	TryStatement: [
+		"block",
+		"handler",
+		"finalizer"
+	],
+	UpdateExpression: ["argument"],
+	UnaryExpression: ["argument"],
+	VariableDeclaration: ["$declarations"],
+	VariableDeclarator: ["id", "init"],
+	WhileStatement: ["test", "body"],
+	WithStatement: ["object", "body"],
+	YieldExpression: ["argument"]
+};
+function visit(ast, config) {
+	let shouldBreak = false;
+	let shouldSkipChildren = false;
+	const traverse = (node, parent, key, index) => {
+		if (shouldBreak) return;
+		let nodeToReplace;
+		let nodeToRemove;
+		const context = {
+			replace(newNode) {
+				nodeToReplace = newNode;
+			},
+			remove() {
+				nodeToRemove = node;
+			},
+			skip() {
+				shouldSkipChildren = true;
+			},
+			break() {
+				shouldBreak = true;
+			}
+		};
+		if (config.enter) {
+			config.enter.call(context, node, parent, key, index);
+			if (shouldBreak) return;
+		}
+		if (config[node.type]) {
+			config[node.type].call(context, node, parent, key, index);
+			if (shouldBreak) return;
+		}
+		if ((nodeToReplace || nodeToRemove) && parent && key) {
+			if (index === void 0) parent[key] = nodeToReplace ?? null;
+			else {
+				const nodes = parent[key];
+				if (nodeToReplace) nodes[index] = nodeToReplace;
+				else nodes.splice(index, 1);
+			}
+			if (nodeToReplace) traverse(nodeToReplace, parent, key, index);
+			return;
+		}
+		if (shouldSkipChildren) shouldSkipChildren = false;
+		else if (ESTreeNodeKeys[node.type]) {
+			const keys = ESTreeNodeKeys[node.type];
+			for (let i = 0; i < keys.length; ++i) {
+				const key$1 = keys[i];
+				if (key$1[0] === "$") {
+					const nodesKey = key$1.slice(1);
+					const values = node[nodesKey];
+					if (!values) continue;
+					let length = values.length;
+					for (let j = 0; j < length; ++j) {
+						const child = values[j];
+						if (!child) continue;
+						traverse(child, node, nodesKey, j);
+						if (shouldBreak) return;
+						if (length > values.length) {
+							length--;
+							j--;
+						}
+					}
+				} else {
+					const nodeKey = key$1;
+					const value = node[nodeKey];
+					if (!value) continue;
+					traverse(value, node, nodeKey);
+					if (shouldBreak) return;
+				}
+			}
+		}
+		if (config.exit) config.exit.call(context, node, parent, key, index);
+	};
+	traverse(ast);
+}
+
+//#endregion
+//#region src/compiler.ts
+const UPPERCASE_REGEX = /^[A-Z]/;
+const NATIVE_EVENT_REGEX = /^on[a-z]+$/;
+const NON_BLANK_LINE_REGEX = /\S|^[^\S\r\n]+$/;
+const EDGE_SPACE_REGEX = /^\s*[\r\n]\s*|[\r\n]\s*$/g;
+const SPACE_REGEX = /\s+/g;
+const IDENTIFIER_REGEX = /^[a-z_$][\w$]*$/i;
+const SVGTags = new Set([
+	"animate",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"clipPath",
+	"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-face",
+	"font-face-format",
+	"font-face-name",
+	"font-face-src",
+	"font-face-uri",
+	"foreignObject",
+	"g",
+	"glyph",
+	"glyphRef",
+	"hkern",
+	"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 MathMLTags = new Set([
+	"annotation",
+	"annotation-xml",
+	"maction",
+	"math",
+	"menclose",
+	"merror",
+	"mfenced",
+	"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"
+]);
+const DOMProperties = new Set([
+	"allowFullscreen",
+	"async",
+	"autofocus",
+	"autoplay",
+	"checked",
+	"controls",
+	"default",
+	"disabled",
+	"formNoValidate",
+	"hidden",
+	"indeterminate",
+	"inert",
+	"innerHTML",
+	"innerText",
+	"isMap",
+	"loop",
+	"multiple",
+	"muted",
+	"noValidate",
+	"nomodule",
+	"open",
+	"playsInline",
+	"readOnly",
+	"required",
+	"reversed",
+	"seamless",
+	"selected",
+	"textContent",
+	"value"
+]);
+const keywords = new Set([
+	"async",
+	"await",
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"let",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"yield"
+]);
+let currentContext;
+function compile(code, options = {}) {
+	let prevFunctionParent;
+	let prevHasThisInFunction;
+	const ast = parse(code, {
+		jsx: true,
+		next: true,
+		module: true,
+		ranges: true,
+		loc: true
+	});
+	currentContext = {
+		config: {
+			sourcemap: options.sourcemap,
+			file: options.file ?? "output.js",
+			sourceRoot: options.sourceRoot ?? "",
+			modulePath: options.modulePath ?? "@zessjs/core"
+		},
+		ast,
+		events: [],
+		eventsCache: /* @__PURE__ */ new Set(),
+		generatedFunctions: /* @__PURE__ */ new WeakSet()
+	};
+	visit(ast, {
+		JSXElement(node) {
+			currentContext.JSXId ??= 0;
+			currentContext.refId ??= 0;
+			currentContext.thisId ??= 0;
+			const stmts = transformElement(node);
+			let expression;
+			if (stmts.length === 1) if (stmts[0].type === "VariableDeclaration") expression = stmts[0].declarations[0].init;
+			else expression = stmts[0].expression;
+			else {
+				const id = stmts[0].declarations[0].id;
+				const callExpressionPosition = copyPosition(node);
+				expression = createCallExpression(createArrowFunctionExpression(createBlockStatement([...stmts, createReturnStatement(id, callExpressionPosition)], callExpressionPosition), callExpressionPosition), [], callExpressionPosition);
+			}
+			currentContext.JSXParent ??= expression;
+			this.replace(expression);
+		},
+		JSXFragment(node) {
+			currentContext.JSXId ??= 0;
+			currentContext.refId ??= 0;
+			currentContext.thisId ??= 0;
+			const expression = transformFragment(node.children, copyPosition(node.openingFragment));
+			currentContext.JSXParent ??= expression;
+			this.replace(expression);
+		},
+		FunctionDeclaration(node) {
+			prevFunctionParent = currentContext.functionParent;
+			prevHasThisInFunction = currentContext.hasThisInFunction;
+			currentContext.functionParent = node;
+			currentContext.hasThisInFunction = false;
+		},
+		FunctionExpression(node) {
+			if (currentContext.generatedFunctions.has(node)) currentContext.generatedFunctions.delete(node);
+			else {
+				prevFunctionParent = currentContext.functionParent;
+				prevHasThisInFunction = currentContext.hasThisInFunction;
+				currentContext.functionParent = node;
+				currentContext.hasThisInFunction = false;
+			}
+		},
+		ArrowFunctionExpression(node, parent, key) {
+			if (parent?.type === "PropertyDefinition" && key === "value") {
+				prevFunctionParent = currentContext.functionParent;
+				prevHasThisInFunction = currentContext.hasThisInFunction;
+				currentContext.functionParent = node;
+				currentContext.hasThisInFunction = false;
+			}
+		},
+		ThisExpression(node) {
+			const expression = transformThisExpression(node);
+			if (expression) this.replace(expression);
+		},
+		exit(node) {
+			if (node === currentContext.functionParent) {
+				currentContext.functionParent = prevFunctionParent;
+				currentContext.hasThisInFunction = prevHasThisInFunction;
+			} else if (node === currentContext.JSXParent) {
+				currentContext.JSXId = void 0;
+				currentContext.refId = void 0;
+				currentContext.thisId = void 0;
+				currentContext.JSXParent = void 0;
+			}
+		}
+	});
+	injectRuntimeImport(ast);
+	const sourceMap = new SourceMapGenerator({
+		file: currentContext.config.file,
+		sourceRoot: currentContext.config.sourceRoot
+	});
+	code = generate(ast, { sourceMap });
+	let map = sourceMap.toJSON();
+	if (currentContext.config.sourcemap) map = merge(currentContext.config.sourcemap, map);
+	return {
+		code,
+		map
+	};
+}
+function transformElement(node) {
+	const stmts = [];
+	const opening = node.openingElement;
+	const tagName = transformJSXTagName(opening.name);
+	const tagNamePosition = copyPosition(tagName);
+	if (tagName.type === "Literal") {
+		const value = tagName.value;
+		const args = [createLiteral(value, tagNamePosition)];
+		const JSXId = createIdentifier(getUniqueId("el", "JSXId"), tagNamePosition);
+		const namespace = SVGTags.has(value) ? 1 : MathMLTags.has(value) ? 2 : 0;
+		if (namespace) args.push(createLiteral(namespace, tagNamePosition));
+		currentContext.shouldImportCreateElement = true;
+		stmts.push(createVariableDeclaration(JSXId, createCallExpression(createIdentifier("_$createElement", tagNamePosition), args, tagNamePosition), tagNamePosition), ...transformAttributes(opening.attributes, JSXId), ...transformChildren(node.children, JSXId));
+	} else {
+		const elementPosition = copyPosition(node);
+		currentContext.shouldImportCreateComponent = true;
+		stmts.push(createExpressionStatement(createCallExpression(createIdentifier("_$createComponent", elementPosition), [tagName, transformProperties(opening.attributes, node.children, copyPosition(opening))], elementPosition), elementPosition));
+	}
+	return stmts;
+}
+function transformFragment(children, position, isInComponent) {
+	const elements = [];
+	let hasDynamicChildren = false;
+	let shouldImportUseMemo = false;
+	let textContent;
+	let textPosition;
+	let elementsPosition;
+	let childExpression;
+	for (let i = 0; i < children.length; ++i) {
+		const childNode = children[i];
+		if (childNode.type === "JSXText") {
+			const text = childNode.value;
+			if (isBlankLine(text)) continue;
+			if (textContent) textContent = `${textContent}${text}`;
+			else {
+				textContent = text;
+				textPosition = copyPosition(childNode);
+				elementsPosition ??= textPosition;
+			}
+		} else if (isJSXEmptyExpression(childNode)) continue;
+		else if (childNode.type === "JSXFragment") children.splice(i--, 1, ...childNode.children);
+		else {
+			const childPosition = copyPosition(childNode);
+			let childElement;
+			if (textContent) {
+				elements.push(createLiteral(decodeText(textContent), textPosition));
+				textContent = textPosition = void 0;
+			}
+			if (childNode.type === "JSXElement") {
+				const stmts = transformElement(childNode);
+				if (isInComponent) hasDynamicChildren = true;
+				if (stmts.length > 1) {
+					const id = stmts[0].declarations[0].id;
+					childElement = createCallExpression(createArrowFunctionExpression(createBlockStatement([...stmts, createReturnStatement(id, childPosition)], childPosition), childPosition), [], childPosition);
+				} else if (stmts[0].type === "VariableDeclaration") childElement = stmts[0].declarations[0].init;
+				else childElement = stmts[0].expression;
+			} else {
+				const expression = childNode.expression;
+				if (isInComponent) childExpression ??= expression;
+				if (isDynamicExpression(expression, isInComponent)) {
+					shouldImportUseMemo = hasDynamicChildren = true;
+					childElement = createCallExpression(createIdentifier("_$memo", childPosition), [!isInComponent && isBareIdentifierCall(expression) ? expression.callee : createArrowFunctionExpression(expression, copyPosition(expression))], childPosition);
+				} else childElement = expression;
+			}
+			elements.push(childElement);
+			elementsPosition ??= childPosition;
+		}
+	}
+	if (textContent) elements.push(createLiteral(decodeText(textContent), textPosition));
+	if (isInComponent) {
+		currentContext.prevHasDynamicChildrenInComponent = currentContext.hasDynamicChildrenInComponent;
+		currentContext.hasDynamicChildrenInComponent = hasDynamicChildren;
+	}
+	if (elements.length > 1) {
+		if (shouldImportUseMemo) currentContext.shouldImportUseMemo = true;
+		return createArrayExpression(elements, elementsPosition);
+	}
+	if (elements.length === 1) {
+		if (!childExpression) {
+			if (shouldImportUseMemo) currentContext.shouldImportUseMemo = true;
+			return elements[0];
+		}
+		return childExpression;
+	}
+	if (!isInComponent) return createArrayExpression(elements, position);
+}
+function transformThisExpression(node) {
+	if (!currentContext.JSXParent) return;
+	const thisId = createIdentifier(getUniqueId("self", "thisId"), copyPosition(node));
+	if (!currentContext.functionParent) {
+		if (currentContext.hasThisInProgram) return thisId;
+		const { body } = currentContext.ast;
+		const programPosition = copyPosition(currentContext.ast);
+		currentContext.hasThisInProgram = true;
+		for (let i = 0; i < body.length; ++i) {
+			if (body[i].type === "ImportDeclaration") continue;
+			body.splice(i, 0, createVariableDeclaration(thisId, createThisExpression(programPosition), programPosition));
+			break;
+		}
+	} else if (!currentContext.hasThisInFunction) {
+		const functionPosition = copyPosition(currentContext.functionParent);
+		const block = currentContext.functionParent.body;
+		const declaration = createVariableDeclaration(thisId, createThisExpression(functionPosition), functionPosition);
+		currentContext.hasThisInFunction = true;
+		if (block.type === "BlockStatement") block.body.unshift(declaration);
+		else currentContext.functionParent.body = createBlockStatement([declaration, createReturnStatement(block, copyPosition(block))], functionPosition);
+	}
+	return thisId;
+}
+function injectRuntimeImport(ast) {
+	const specifiers = [];
+	const programPosition = copyPosition(ast);
+	if (currentContext.shouldImportCreateComponent) specifiers.push(createImportSpecifier("_$createComponent", "createComponent", programPosition));
+	if (currentContext.shouldImportCreateElement) specifiers.push(createImportSpecifier("_$createElement", "createElement", programPosition));
+	if (currentContext.events.length) {
+		specifiers.push(createImportSpecifier("_$delegateEvents", "delegateEvents", programPosition));
+		ast.body.push(createExpressionStatement(createCallExpression(createIdentifier("_$delegateEvents", programPosition), [createArrayExpression(currentContext.events, programPosition)], programPosition), programPosition));
+	}
+	if (currentContext.shouldImportInsert) specifiers.push(createImportSpecifier("_$insert", "insert", programPosition));
+	if (currentContext.shouldImportMergeProps) specifiers.push(createImportSpecifier("_$mergeProps", "mergeProps", programPosition));
+	if (currentContext.shouldImportSetAttribute) specifiers.push(createImportSpecifier("_$setAttribute", "setAttribute", programPosition));
+	if (currentContext.shouldImportSetAttributeNS) specifiers.push(createImportSpecifier("_$setAttributeNS", "setAttributeNS", programPosition));
+	if (currentContext.shouldImportSetClassName) specifiers.push(createImportSpecifier("_$className", "setClassName", programPosition));
+	if (currentContext.shouldImportSetStyle) specifiers.push(createImportSpecifier("_$style", "setStyle", programPosition));
+	if (currentContext.shouldImportSpread) specifiers.push(createImportSpecifier("_$spread", "spread", programPosition));
+	if (currentContext.shouldImportUse) specifiers.push(createImportSpecifier("_$use", "use", programPosition));
+	if (currentContext.shouldImportUseEffect) specifiers.push(createImportSpecifier("_$effect", "useRenderEffect", programPosition));
+	if (currentContext.shouldImportUseMemo) specifiers.push(createImportSpecifier("_$memo", "useMemo", programPosition));
+	if (specifiers.length) ast.body.unshift({
+		type: "ImportDeclaration",
+		specifiers,
+		attributes: [],
+		source: createLiteral(currentContext.config.modulePath, programPosition),
+		...programPosition
+	});
+}
+function transformJSXTagName(node) {
+	const tagNamePosition = copyPosition(node);
+	if (node.type === "JSXNamespacedName") {
+		const namespace = node.namespace;
+		return createLiteral(`${namespace.name}:${node.name.name}`, tagNamePosition);
+	}
+	let object;
+	let expression;
+	if (node.type === "JSXMemberExpression") {
+		object = expression = tagNamePosition;
+		do {
+			const isValidPropertyName = isValidIdentifier(node.property.name);
+			const propertyPosition = copyPosition(node.property);
+			object.type = "MemberExpression";
+			object.property = isValidPropertyName ? createIdentifier(node.property.name, propertyPosition) : createLiteral(node.property.name, propertyPosition);
+			object.computed = !isValidPropertyName;
+			object.object = object = copyPosition(node.object);
+			node = node.object;
+		} while (node.type === "JSXMemberExpression");
+	}
+	const tagName = node;
+	if (tagName.name === "this") {
+		const id = transformThisExpression(tagName);
+		if (expression) {
+			object.type = "Identifier";
+			object.name = id.name;
+		} else expression = id;
+	} else if (expression || UPPERCASE_REGEX.test(tagName.name)) if (expression) {
+		object.type = "Identifier";
+		object.name = tagName.name;
+	} else expression = createIdentifier(tagName.name, tagNamePosition);
+	else expression = createLiteral(tagName.name, tagNamePosition);
+	return expression;
+}
+function transformAttributes(attrs, id) {
+	const stmts = [];
+	const attributeNameCache = new Set(["children"]);
+	let shouldImportSpread = false;
+	let shouldImportMergeProps = false;
+	let properties = [];
+	let shouldImportSetStyle;
+	let shouldImportSetClassName;
+	let shouldImportSetAttribute;
+	let shouldImportSetAttributeNS;
+	let shouldImportUseEffect;
+	let ref;
+	let events;
+	let objectPosition;
+	let spreadArgs;
+	let spreadArgsPosition;
+	let effect;
+	let effectProperty;
+	let effectStmts;
+	let effectParameter;
+	let effectFunction;
+	let effectPosition;
+	let dynamicCount;
+	for (let i = 0; i < attrs.length; ++i) {
+		let expression;
+		const attr = attrs[i];
+		const attributePosition = copyPosition(attr);
+		if (attr.type === "JSXAttribute") {
+			const attributeName = getAttributeName(attr.name);
+			if (attributeNameCache.has(attributeName)) continue;
+			let value;
+			let isDynamicValue = false;
+			const attributeNamePosition = copyPosition(attr.name);
+			attributeNameCache.add(attributeName);
+			if (!attr.value) value = createLiteral(true, attributeNamePosition);
+			else if (attr.value.type === "Literal") value = attr.value;
+			else if (attr.value.type === "JSXExpressionContainer") {
+				expression = attr.value.expression;
+				if (attributeName === "ref") {
+					if (matchesType(expression, isRightValue)) {
+						const refId = createIdentifier(getUniqueId("ref", "refId"), attributeNamePosition);
+						const binaryExpression = createBinaryExpression(createUnaryExpression(refId, attributePosition), createLiteral("function", attributePosition), "===", attributePosition);
+						const callExpression = createCallExpression(createIdentifier("_$use", attributePosition), [refId, id], attributePosition);
+						currentContext.shouldImportUse = true;
+						ref = [createVariableDeclaration(refId, expression, attributePosition), createExpressionStatement(isLeftValue(expression) ? createConditionalExpression(binaryExpression, callExpression, createAssignmentExpression(expression, id, attributePosition), attributePosition) : createLogicalExpression(binaryExpression, callExpression, attributePosition), attributePosition)];
+						continue;
+					}
+					if (isFunctionExpression(expression)) {
+						currentContext.shouldImportUse = true;
+						ref = [createExpressionStatement(createCallExpression(createIdentifier("_$use", attributePosition), [expression, id], attributePosition), attributePosition)];
+						continue;
+					}
+				} else if (!shouldImportSpread && attributeName.startsWith("on") && matchesType(expression, isListener)) {
+					let eventName;
+					if (NATIVE_EVENT_REGEX.test(attributeName)) eventName = attributeName;
+					else {
+						eventName = attributeName.slice(2).toLowerCase();
+						if (eventName === "doubleclick") eventName = "dblclick";
+						if (!currentContext.eventsCache.has(eventName)) {
+							currentContext.eventsCache.add(eventName);
+							currentContext.events.push(createLiteral(eventName, attributeNamePosition));
+						}
+						eventName = `$$${eventName}`;
+					}
+					(events ??= []).push(createExpressionStatement(createAssignmentExpression(createMemberExpression(id, createIdentifier(eventName, attributeNamePosition), false, attributeNamePosition), expression, attributePosition), attributePosition));
+					continue;
+				}
+				value = expression;
+				isDynamicValue = isDynamicExpression(value);
+			}
+			const isValidPropertyName = isValidIdentifier(attributeName);
+			const property = createProperty(isValidPropertyName ? createIdentifier(attributeName, attributeNamePosition) : createLiteral(attributeName, attributeNamePosition), isDynamicValue ? createFunctionExpression([createReturnStatement(value, attributePosition)]) : value, isDynamicValue ? "get" : "init", !isValidPropertyName, false, attributePosition);
+			objectPosition ??= attributePosition;
+			properties.push(property);
+			if (shouldImportSpread) continue;
+			let styleOrClassArgs;
+			if (attributeName === "style") if (matchesType(value, isStylesheet)) {
+				shouldImportSetStyle = true;
+				expression = createCallExpression(createIdentifier("_$style", attributeNamePosition), styleOrClassArgs = [id, value], attributePosition);
+			} else expression = createAssignmentExpression(createMemberExpression(createMemberExpression(id, createIdentifier(attributeName, attributeNamePosition), false, attributeNamePosition), createIdentifier("cssText", attributeNamePosition), false, attributeNamePosition), value, attributePosition);
+			else if (attributeName === "class" || attributeName === "className") if (matchesType(value, isStylesheet)) {
+				shouldImportSetClassName = true;
+				expression = createCallExpression(createIdentifier("_$className", attributeNamePosition), styleOrClassArgs = [id, value], attributePosition);
+			} else {
+				shouldImportSetAttribute = true;
+				expression = createCallExpression(createIdentifier("_$setAttribute", attributeNamePosition), [
+					id,
+					createLiteral("class", attributeNamePosition),
+					value
+				], attributePosition);
+			}
+			else if (DOMProperties.has(attributeName) || attributeName.startsWith("on")) expression = createAssignmentExpression(createMemberExpression(id, createIdentifier(attributeName, attributeNamePosition), false, attributeNamePosition), value, attributePosition);
+			else {
+				let method;
+				let attributeArgs;
+				const prefix = attributeName.split(":")[0];
+				const namespace = prefix === "xlink" ? 3 : prefix === "xml" ? 4 : 0;
+				const name = createLiteral(attributeName, attributeNamePosition);
+				if (namespace) {
+					method = "_$setAttributeNS";
+					shouldImportSetAttributeNS = true;
+					attributeArgs = [
+						id,
+						createLiteral(namespace, attributeNamePosition),
+						name,
+						value
+					];
+				} else {
+					method = "_$setAttribute";
+					shouldImportSetAttribute = true;
+					attributeArgs = [
+						id,
+						name,
+						value
+					];
+				}
+				expression = createCallExpression(createIdentifier(method, attributeNamePosition), attributeArgs, attributePosition);
+			}
+			if (isDynamicValue) {
+				if (effect) {
+					let valueId;
+					let effectKey;
+					let member;
+					let object;
+					let assignment;
+					let declaration;
+					if (effect.arguments.length === 1) {
+						let hasEffectParameter;
+						let effectValue;
+						let effectCall = effectFunction.body;
+						effectKey = effectProperty.key;
+						if (effectParameter) hasEffectParameter = true;
+						else {
+							hasEffectParameter = false;
+							effectParameter = createIdentifier(getUniqueId("p"), effectPosition);
+						}
+						dynamicCount = 0;
+						valueId = createIdentifier(getUniqueId("v", ++dynamicCount), effectPosition);
+						member = createMemberExpression(effectParameter, effectKey, effectProperty.computed, effectPosition);
+						if (hasEffectParameter) {
+							const args = effectCall.arguments;
+							effectValue = args[1];
+							args[1] = valueId;
+							args[2] = member;
+							effectCall = createAssignmentExpression(member, effectCall, effectPosition);
+						} else {
+							assignment = createAssignmentExpression(member, valueId, effectPosition);
+							if (effectCall.type === "CallExpression") {
+								const index = effectCall.arguments.length - 1;
+								effectValue = effectCall.arguments[index];
+								effectCall.arguments[index] = assignment;
+							} else {
+								effectValue = effectCall.right;
+								effectCall.right = assignment;
+							}
+							effectCall = createLogicalExpression(createBinaryExpression(valueId, member, "!==", effectPosition), effectCall, effectPosition);
+							effectFunction.params.push(effectParameter);
+						}
+						declaration = createVariableDeclaration(valueId, effectValue, effectPosition);
+						effectStmts = [declaration, createExpressionStatement(effectCall, effectPosition)];
+						effectFunction.body = createBlockStatement(effectStmts, effectPosition);
+						object = createObjectExpression([createProperty(effectKey, createIdentifier("undefined", effectPosition), "init", effectProperty.computed, false, effectPosition)], effectPosition);
+						effect.arguments.push(object);
+					} else {
+						object = effect.arguments[1];
+						declaration = effectStmts[0];
+					}
+					effectKey = property.key;
+					valueId = createIdentifier(getUniqueId("v", ++dynamicCount), attributePosition);
+					member = createMemberExpression(effectParameter, effectKey, property.computed, attributePosition);
+					if (styleOrClassArgs) {
+						styleOrClassArgs[1] = valueId;
+						styleOrClassArgs.push(member);
+						expression = createAssignmentExpression(member, expression, attributePosition);
+					} else {
+						assignment = createAssignmentExpression(member, valueId, attributePosition);
+						if (expression.type === "CallExpression") expression.arguments[expression.arguments.length - 1] = assignment;
+						else expression.right = assignment;
+						expression = createLogicalExpression(createBinaryExpression(valueId, member, "!==", attributePosition), expression, attributePosition);
+					}
+					object.properties.push(createProperty(effectKey, createIdentifier("undefined", attributePosition), "init", property.computed, false, attributePosition));
+					declaration.declarations.push(createVariableDeclarator(valueId, value, attributePosition));
+					effectStmts.push(createExpressionStatement(expression, attributePosition));
+					continue;
+				}
+				effectProperty = property;
+				effectPosition = attributePosition;
+				effectFunction = createArrowFunctionExpression(expression, effectPosition);
+				if (styleOrClassArgs) {
+					effectParameter = createIdentifier(getUniqueId("p"), effectPosition);
+					effectFunction.params.push(effectParameter);
+					styleOrClassArgs.push(effectParameter);
+				}
+				shouldImportUseEffect = true;
+				expression = effect = createCallExpression(createIdentifier("_$effect", effectPosition), [effectFunction], effectPosition);
+			}
+		} else {
+			let { argument } = attr;
+			spreadArgs ??= [id];
+			if (properties.length) {
+				spreadArgs.push(createObjectExpression(properties, objectPosition));
+				properties = [];
+				spreadArgsPosition ??= objectPosition;
+				objectPosition = void 0;
+			}
+			if (isDynamicExpression(argument)) {
+				shouldImportMergeProps = true;
+				argument = isBareIdentifierCall(argument) ? argument.callee : createArrowFunctionExpression(argument, copyPosition(argument));
+			}
+			spreadArgs.push(argument);
+			if (shouldImportSpread) continue;
+			currentContext.shouldImportSpread = shouldImportSpread = true;
+			spreadArgsPosition ??= attributePosition;
+			shouldImportSetStyle = false;
+			shouldImportSetClassName = false;
+			shouldImportSetAttribute = false;
+			shouldImportSetAttributeNS = false;
+			shouldImportUseEffect = false;
+			stmts.length = 0;
+			expression = createCallExpression(createIdentifier("_$spread", attributePosition), spreadArgs, attributePosition);
+		}
+		stmts.push(createExpressionStatement(expression, attributePosition));
+	}
+	if (spreadArgs) {
+		if (properties.length) spreadArgs.push(createObjectExpression(properties, objectPosition));
+		if (shouldImportMergeProps || spreadArgs.length > 2) {
+			currentContext.shouldImportMergeProps = true;
+			spreadArgs.splice(1, spreadArgs.length - 1, createCallExpression(createIdentifier("_$mergeProps", spreadArgsPosition), spreadArgs.slice(1), spreadArgsPosition));
+		}
+	} else {
+		if (shouldImportSetStyle) currentContext.shouldImportSetStyle = true;
+		if (shouldImportSetClassName) currentContext.shouldImportSetClassName = true;
+		if (shouldImportSetAttribute) currentContext.shouldImportSetAttribute = true;
+		if (shouldImportSetAttributeNS) currentContext.shouldImportSetAttributeNS = true;
+		if (shouldImportUseEffect) {
+			currentContext.shouldImportUseEffect = true;
+			if (effectStmts) effectStmts.push(createReturnStatement(effectParameter, effectPosition));
+		}
+	}
+	if (events) stmts.unshift(...events);
+	if (ref) stmts.unshift(...ref);
+	return stmts;
+}
+function transformChildren(children, id) {
+	const stmts = [];
+	let elements = [];
+	let textContent;
+	let textPosition;
+	let elementsPosition;
+	for (let i = 0; i < children.length; ++i) {
+		const childNode = children[i];
+		if (childNode.type === "JSXText") {
+			const text = childNode.value;
+			if (isBlankLine(text)) continue;
+			if (textContent) textContent = `${textContent}${text}`;
+			else {
+				textContent = text;
+				textPosition = copyPosition(childNode);
+				elementsPosition ??= textPosition;
+			}
+		} else if (isJSXEmptyExpression(childNode)) continue;
+		else if (childNode.type === "JSXFragment") children.splice(i--, 1, ...childNode.children);
+		else {
+			const childPosition = copyPosition(childNode);
+			let expression;
+			if (textContent) {
+				elements.push(createLiteral(decodeText(textContent), textPosition));
+				textContent = textPosition = void 0;
+			}
+			if (childNode.type === "JSXElement") {
+				const childStmts = transformElement(childNode);
+				if (childStmts.length > 1) {
+					const stmt = childStmts[0];
+					elements.push(stmt.declarations[0].id);
+					elementsPosition ??= childPosition;
+					stmts.push(...childStmts);
+					continue;
+				} else if (childStmts[0].type === "VariableDeclaration") {
+					elements.push(childStmts[0].declarations[0].init);
+					elementsPosition ??= childPosition;
+					continue;
+				} else expression = childStmts[0].expression;
+			} else {
+				expression = childNode.expression;
+				if (isBareIdentifierCall(expression)) expression = expression.callee;
+				else if (isDynamicExpression(expression)) expression = createArrowFunctionExpression(expression, copyPosition(expression));
+			}
+			if (elements.length) {
+				stmts.push(createExpressionStatement(createCallExpression(createMemberExpression(id, createIdentifier("append", elementsPosition), false, elementsPosition), elements, elementsPosition), elementsPosition));
+				elements = [];
+				elementsPosition = void 0;
+			}
+			currentContext.shouldImportInsert = true;
+			stmts.push(createExpressionStatement(createCallExpression(createIdentifier("_$insert", childPosition), [id, expression], childPosition), childPosition));
+		}
+	}
+	if (textContent) elements.push(createLiteral(decodeText(textContent), textPosition));
+	if (elements.length) stmts.push(createExpressionStatement(createCallExpression(createMemberExpression(id, createIdentifier("append", elementsPosition), false, elementsPosition), elements, elementsPosition), elementsPosition));
+	return stmts;
+}
+function transformProperties(attrs, children, position) {
+	const args = [];
+	const propertyNameCache = new Set(["children"]);
+	let shouldImportMergeProps = false;
+	let properties = [];
+	let objectPosition;
+	let argsPosition;
+	for (let i = 0; i < attrs.length; ++i) {
+		const attr = attrs[i];
+		const propertyPosition = copyPosition(attr);
+		if (attr.type === "JSXAttribute") {
+			const propertyName = getAttributeName(attr.name);
+			if (propertyNameCache.has(propertyName)) continue;
+			let value;
+			let isDynamicValue = false;
+			const propertyNamePosition = copyPosition(attr.name);
+			propertyNameCache.add(propertyName);
+			if (!attr.value) value = createLiteral(true, propertyNamePosition);
+			else if (attr.value.type === "Literal") value = attr.value;
+			else if (attr.value.type === "JSXExpressionContainer") {
+				const expression = attr.value.expression;
+				if (propertyName === "ref") {
+					if (matchesType(expression, isRightValue)) {
+						const refId = createIdentifier(getUniqueId("ref", "refId"), propertyNamePosition);
+						const argument = createIdentifier(getUniqueId("r"), copyPosition(expression));
+						const binaryExpression = createBinaryExpression(createUnaryExpression(refId, propertyPosition), createLiteral("function", propertyPosition), "===", propertyPosition);
+						const callExpression = createCallExpression(refId, [argument], propertyPosition);
+						objectPosition ??= propertyPosition;
+						properties.push(createProperty(createIdentifier(propertyName, propertyNamePosition), createFunctionExpression([createVariableDeclaration(refId, expression, propertyPosition), createExpressionStatement(isLeftValue(expression) ? createConditionalExpression(binaryExpression, callExpression, createAssignmentExpression(expression, argument, propertyPosition), propertyPosition) : createLogicalExpression(binaryExpression, callExpression, propertyPosition), propertyPosition)], argument), "init", false, true, propertyPosition));
+					} else if (isFunctionExpression(expression)) {
+						objectPosition ??= propertyPosition;
+						properties.push(createProperty(createIdentifier(propertyName, propertyNamePosition), expression, "init", false, false, propertyPosition));
+					}
+					continue;
+				}
+				value = expression;
+				isDynamicValue = isDynamicExpression(value, true);
+			}
+			const isValidPropertyName = isValidIdentifier(propertyName);
+			objectPosition ??= propertyPosition;
+			properties.push(createProperty(isValidPropertyName ? createIdentifier(propertyName, propertyNamePosition) : createLiteral(propertyName, propertyNamePosition), isDynamicValue ? createFunctionExpression([createReturnStatement(value, propertyPosition)]) : value, isDynamicValue ? "get" : "init", !isValidPropertyName, false, propertyPosition));
+		} else {
+			let { argument } = attr;
+			if (properties.length) {
+				args.push(createObjectExpression(properties, objectPosition));
+				properties = [];
+				argsPosition ??= objectPosition;
+				objectPosition = void 0;
+			}
+			if (isDynamicExpression(argument)) {
+				shouldImportMergeProps = true;
+				argument = isBareIdentifierCall(argument) ? argument.callee : createArrowFunctionExpression(argument, copyPosition(argument));
+			}
+			args.push(argument);
+			argsPosition ??= propertyPosition;
+		}
+	}
+	if (children.length) {
+		const childrenPosition = copyPosition(children[0]);
+		const childrenExpression = transformFragment(children, childrenPosition, true);
+		if (childrenExpression) {
+			const hasDynamicChildren = currentContext.hasDynamicChildrenInComponent;
+			properties.push(createProperty(createIdentifier("children", childrenPosition), hasDynamicChildren ? createFunctionExpression([createReturnStatement(childrenExpression, childrenPosition)]) : childrenExpression, hasDynamicChildren ? "get" : "init", false, false, childrenPosition));
+		}
+		currentContext.hasDynamicChildrenInComponent = currentContext.prevHasDynamicChildrenInComponent;
+	}
+	if (properties.length) {
+		args.push(createObjectExpression(properties, objectPosition));
+		argsPosition ??= objectPosition;
+	}
+	if (shouldImportMergeProps || args.length > 1) {
+		currentContext.shouldImportMergeProps = true;
+		return createCallExpression(createIdentifier("_$mergeProps", argsPosition), args, argsPosition);
+	}
+	if (args.length === 1) return args[0];
+	return createObjectExpression(properties, position);
+}
+function getAttributeName(node) {
+	if (node.type === "JSXIdentifier") return node.name;
+	return `${node.namespace.name}:${node.name.name}`;
+}
+function copyPosition(node) {
+	return {
+		start: node.start,
+		end: node.end,
+		range: node.range,
+		loc: node.loc
+	};
+}
+function createExpressionStatement(expression, position) {
+	return {
+		type: "ExpressionStatement",
+		expression,
+		...position
+	};
+}
+function createVariableDeclaration(id, init, position) {
+	return {
+		type: "VariableDeclaration",
+		kind: "const",
+		declarations: [createVariableDeclarator(id, init, position)],
+		...position
+	};
+}
+function createReturnStatement(argument, position) {
+	return {
+		type: "ReturnStatement",
+		argument,
+		...position
+	};
+}
+function createBlockStatement(body, position) {
+	return {
+		type: "BlockStatement",
+		body,
+		...position
+	};
+}
+function createArrowFunctionExpression(body, position) {
+	return {
+		type: "ArrowFunctionExpression",
+		params: [],
+		body,
+		async: false,
+		generator: false,
+		expression: body.type !== "BlockStatement",
+		...position
+	};
+}
+function createFunctionExpression(body, parameter) {
+	const functionPosition = copyPosition(body[0]);
+	const FunctionExpression = {
+		type: "FunctionExpression",
+		params: parameter ? [parameter] : [],
+		body: createBlockStatement(body, functionPosition),
+		async: false,
+		generator: false,
+		id: null,
+		...functionPosition
+	};
+	currentContext.generatedFunctions.add(FunctionExpression);
+	return FunctionExpression;
+}
+function createCallExpression(callee, args, position) {
+	return {
+		type: "CallExpression",
+		callee,
+		arguments: args,
+		optional: false,
+		...position
+	};
+}
+function createMemberExpression(object, property, computed, position) {
+	return {
+		type: "MemberExpression",
+		object,
+		property,
+		computed,
+		optional: false,
+		...position
+	};
+}
+function createProperty(key, value, kind, computed, method, position) {
+	return {
+		type: "Property",
+		key,
+		value,
+		kind,
+		computed,
+		method,
+		shorthand: false,
+		...position
+	};
+}
+function createImportSpecifier(local, imported, position) {
+	return {
+		type: "ImportSpecifier",
+		local: createIdentifier(local, position),
+		imported: createIdentifier(imported, position),
+		...position
+	};
+}
+function createObjectExpression(properties, position) {
+	return {
+		type: "ObjectExpression",
+		properties,
+		...position
+	};
+}
+function createArrayExpression(elements, position) {
+	return {
+		type: "ArrayExpression",
+		elements,
+		...position
+	};
+}
+function createAssignmentExpression(left, right, position) {
+	return {
+		type: "AssignmentExpression",
+		left,
+		right,
+		operator: "=",
+		...position
+	};
+}
+function createBinaryExpression(left, right, operator, position) {
+	return {
+		type: "BinaryExpression",
+		left,
+		right,
+		operator,
+		...position
+	};
+}
+function createLogicalExpression(left, right, position) {
+	return {
+		type: "LogicalExpression",
+		left,
+		right,
+		operator: "&&",
+		...position
+	};
+}
+function createConditionalExpression(test, consequent, alternate, position) {
+	return {
+		type: "ConditionalExpression",
+		test,
+		consequent,
+		alternate,
+		...position
+	};
+}
+function createUnaryExpression(argument, position) {
+	return {
+		type: "UnaryExpression",
+		operator: "typeof",
+		argument,
+		prefix: true,
+		...position
+	};
+}
+function createVariableDeclarator(id, init, position) {
+	return {
+		type: "VariableDeclarator",
+		id,
+		init,
+		...position
+	};
+}
+function createIdentifier(name, position) {
+	return {
+		type: "Identifier",
+		name,
+		...position
+	};
+}
+function createLiteral(value, position) {
+	return {
+		type: "Literal",
+		value,
+		raw: JSON.stringify(value),
+		...position
+	};
+}
+function createThisExpression(position) {
+	return {
+		type: "ThisExpression",
+		...position
+	};
+}
+function getUniqueId(prefix, key) {
+	let id;
+	if (currentContext[key] != null && currentContext[key]++) id = currentContext[key];
+	else if (key > 1) id = key;
+	else id = "";
+	return `_${prefix}$${id}`;
+}
+function isBlankLine(text) {
+	return !NON_BLANK_LINE_REGEX.test(text);
+}
+function decodeText(text) {
+	return decodeHTML(text.replaceAll(EDGE_SPACE_REGEX, "").replaceAll(SPACE_REGEX, " "));
+}
+function isValidIdentifier(name) {
+	return IDENTIFIER_REGEX.test(name) && !keywords.has(name);
+}
+function matchesType(node, predicate) {
+	if (predicate(node)) return true;
+	if (node.type === "LogicalExpression") return predicate(node.left) || predicate(node.right);
+	if (node.type === "ConditionalExpression") return predicate(node.consequent) || predicate(node.alternate);
+	if (node.type === "AssignmentExpression") return predicate(node.right);
+	if (node.type === "AwaitExpression") return predicate(node.argument);
+	if (node.type === "YieldExpression" && node.argument) return predicate(node.argument);
+	if (node.type === "SequenceExpression") return predicate(node.expressions.at(-1));
+	return false;
+}
+function isListener(node) {
+	return isFunctionExpression(node) || isRightValue(node);
+}
+function isStylesheet(node) {
+	return node.type === "ObjectExpression" || isRightValue(node);
+}
+function isRightValue(node) {
+	return isLeftValue(node) || node.type === "CallExpression" || node.type === "ChainExpression" || node.type === "JSXElement" || node.type === "JSXFragment" || node.type === "ThisExpression" || node.type === "NewExpression" || node.type === "TaggedTemplateExpression" || node.type === "ImportExpression" || node.type === "MetaProperty";
+}
+function isLeftValue(node) {
+	return node.type === "Identifier" || node.type === "MemberExpression";
+}
+function isFunctionExpression(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+function isBareIdentifierCall(node) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.arguments.length === 0;
+}
+function isJSXEmptyExpression(node) {
+	return node.type === "JSXEmptyExpression" || (node.type === "JSXExpressionContainer" || node.type === "JSXSpreadChild") && node.expression.type === "JSXEmptyExpression";
+}
+function isDynamicExpression(node, checkTags) {
+	let isDynamic = false;
+	visit(node, {
+		ArrowFunctionExpression() {
+			this.skip();
+		},
+		FunctionExpression() {
+			this.skip();
+		},
+		CallExpression() {
+			isDynamic = true;
+			this.break();
+		},
+		MemberExpression() {
+			isDynamic = true;
+			this.break();
+		},
+		ChainExpression() {
+			isDynamic = true;
+			this.break();
+		},
+		JSXElement() {
+			if (checkTags) {
+				isDynamic = true;
+				this.break();
+			}
+		},
+		JSXFragment(node$1) {
+			if (checkTags && node$1.children.length) {
+				isDynamic = true;
+				this.break();
+			}
+		}
+	});
+	return isDynamic;
+}
+
+//#endregion
+export { compile };