@geajs/vite-plugin 1.0.19 → 1.0.21

package/dist/index.js

@@ -1827,7 +1827,7 @@ function generate(node) {
 import * as t22 from "@babel/types";
 
 // src/analyze.ts
-import * as t8 from "@babel/types";
+import * as t9 from "@babel/types";
 
 // src/template-param-utils.ts
 import * as t4 from "@babel/types";
@@ -1840,43 +1840,285 @@ function getTemplateParamBinding(param) {
   return void 0;
 }
 
+// src/component-event-helpers.ts
+import * as t5 from "@babel/types";
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+var EVENT_NAMES = /* @__PURE__ */ new Set([
+  "click",
+  "dblclick",
+  "mousedown",
+  "mouseup",
+  "mouseover",
+  "mouseout",
+  "mousemove",
+  "keydown",
+  "keyup",
+  "keypress",
+  "focus",
+  "blur",
+  "input",
+  "change",
+  "submit",
+  "scroll",
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "tap",
+  "longTap",
+  "swipeRight",
+  "swipeUp",
+  "swipeLeft",
+  "swipeDown",
+  "dragstart",
+  "dragend",
+  "dragover",
+  "dragleave",
+  "drop"
+]);
+function toGeaEventType(attrName) {
+  if (attrName.startsWith("on") && attrName.length > 2) {
+    const rest = attrName.slice(2);
+    return rest.charAt(0).toLowerCase() + rest.slice(1);
+  }
+  return attrName;
+}
+function getPropContext(params) {
+  const context = {
+    destructuredPropNames: /* @__PURE__ */ new Set()
+  };
+  const firstParam = params?.[0];
+  if (!firstParam || t5.isRestElement(firstParam)) return context;
+  const binding = getTemplateParamBinding(firstParam);
+  if (!binding) return context;
+  if (t5.isIdentifier(binding)) {
+    context.propsParamName = binding.name;
+    return context;
+  }
+  context.propsParamName = "props";
+  binding.properties.forEach((prop) => {
+    if (t5.isObjectProperty(prop) && t5.isIdentifier(prop.key)) {
+      context.destructuredPropNames.add(prop.key.name);
+    }
+  });
+  return context;
+}
+function getRootClassSelector(node) {
+  for (const attr of node.openingElement.attributes) {
+    if (!t5.isJSXAttribute(attr) || !t5.isJSXIdentifier(attr.name)) continue;
+    if (attr.name.name !== "class" && attr.name.name !== "className") continue;
+    let firstClass = "";
+    if (t5.isStringLiteral(attr.value)) {
+      firstClass = attr.value.value.trim().split(/\s+/)[0] || "";
+    } else if (t5.isJSXExpressionContainer(attr.value) && !t5.isJSXEmptyExpression(attr.value.expression)) {
+      const expr = attr.value.expression;
+      if (t5.isStringLiteral(expr)) {
+        firstClass = expr.value.trim().split(/\s+/)[0] || "";
+      } else if (t5.isTemplateLiteral(expr)) {
+        firstClass = expr.quasis[0]?.value.raw.trim().split(/\s+/)[0] || "";
+      }
+    }
+    if (firstClass) return `.${firstClass}`;
+  }
+  return null;
+}
+function resolvePropCallbackName(expr, context) {
+  if (t5.isIdentifier(expr) && context.destructuredPropNames.has(expr.name)) {
+    return expr.name;
+  }
+  if (t5.isMemberExpression(expr) && t5.isIdentifier(expr.property) && t5.isIdentifier(expr.object) && expr.object.name === (context.propsParamName || "props")) {
+    return expr.property.name;
+  }
+  if (t5.isMemberExpression(expr) && t5.isIdentifier(expr.property) && t5.isMemberExpression(expr.object) && t5.isIdentifier(expr.object.property) && expr.object.property.name === "props" && (t5.isThisExpression(expr.object.object) || t5.isIdentifier(expr.object.object) && expr.object.object.name === (context.propsParamName || "props"))) {
+    return expr.property.name;
+  }
+  return null;
+}
+function extractSingleCallExpression(expr) {
+  if (t5.isCallExpression(expr)) return expr;
+  if (t5.isArrowFunctionExpression(expr) || t5.isFunctionExpression(expr)) {
+    if (t5.isCallExpression(expr.body)) return expr.body;
+    if (!t5.isBlockStatement(expr.body) || expr.body.body.length !== 1) return null;
+    const stmt = expr.body.body[0];
+    if (t5.isExpressionStatement(stmt) && t5.isCallExpression(stmt.expression)) return stmt.expression;
+    if (t5.isReturnStatement(stmt) && stmt.argument && t5.isCallExpression(stmt.argument)) return stmt.argument;
+  }
+  return null;
+}
+function getHoistableRootEvent(attrName, expr, elementPath, context, selector) {
+  if (elementPath.length !== 0 || !selector) return null;
+  if (attrName.startsWith("data-") || attrName === "class" || attrName === "className" || attrName === "style" || attrName === "id")
+    return null;
+  const eventType = toGeaEventType(attrName);
+  const directProp = resolvePropCallbackName(expr, context);
+  if (directProp) return { eventType, propName: directProp, selector };
+  const callExpr = extractSingleCallExpression(expr);
+  if (!callExpr) return null;
+  const propName = resolvePropCallbackName(callExpr.callee, context);
+  if (!propName) return null;
+  return { eventType, propName, selector };
+}
+function resolveImportPath(importer, source) {
+  const base = resolve(dirname(importer), source);
+  const candidates = [
+    base,
+    `${base}.js`,
+    `${base}.jsx`,
+    `${base}.ts`,
+    `${base}.tsx`,
+    resolve(base, "index.js"),
+    resolve(base, "index.jsx"),
+    resolve(base, "index.ts"),
+    resolve(base, "index.tsx")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function getReturnedRootJSX(ast, componentClassName) {
+  let found = null;
+  for (const stmt of ast.program.body) {
+    if (t5.isExportDefaultDeclaration(stmt)) {
+      const decl = stmt.declaration;
+      if (t5.isFunctionDeclaration(decl) && decl.body) {
+        const ret = decl.body.body.find(
+          (node) => t5.isReturnStatement(node) && node.argument && t5.isJSXElement(node.argument)
+        );
+        if (ret && t5.isReturnStatement(ret) && ret.argument && t5.isJSXElement(ret.argument)) {
+          return { jsx: ret.argument, context: getPropContext(decl.params) };
+        }
+      }
+      if (t5.isIdentifier(decl)) {
+        for (const bodyStmt of ast.program.body) {
+          if (!t5.isVariableDeclaration(bodyStmt)) continue;
+          for (const dec of bodyStmt.declarations) {
+            if (!t5.isIdentifier(dec.id, { name: decl.name })) continue;
+            if (!dec.init || !t5.isArrowFunctionExpression(dec.init) && !t5.isFunctionExpression(dec.init)) continue;
+            const fn = dec.init;
+            if (t5.isJSXElement(fn.body)) return { jsx: fn.body, context: getPropContext(fn.params) };
+            if (t5.isBlockStatement(fn.body)) {
+              const ret = fn.body.body.find(
+                (node) => t5.isReturnStatement(node) && node.argument && t5.isJSXElement(node.argument)
+              );
+              if (ret && t5.isReturnStatement(ret) && ret.argument && t5.isJSXElement(ret.argument)) {
+                return { jsx: ret.argument, context: getPropContext(fn.params) };
+              }
+            }
+          }
+        }
+      }
+    }
+    if (componentClassName && t5.isExportDefaultDeclaration(stmt) && t5.isClassDeclaration(stmt.declaration) && t5.isIdentifier(stmt.declaration.id, { name: componentClassName })) {
+      const templateMethod = stmt.declaration.body.body.find(
+        (member) => t5.isClassMethod(member) && t5.isIdentifier(member.key) && member.key.name === "template"
+      );
+      if (!templateMethod || !t5.isBlockStatement(templateMethod.body)) return null;
+      const ret = templateMethod.body.body.find(
+        (node) => t5.isReturnStatement(node) && node.argument && t5.isJSXElement(node.argument)
+      );
+      if (ret && t5.isReturnStatement(ret) && ret.argument && t5.isJSXElement(ret.argument)) {
+        return {
+          jsx: ret.argument,
+          context: getPropContext(templateMethod.params)
+        };
+      }
+    }
+  }
+  for (const stmt of ast.program.body) {
+    if (!componentClassName || !t5.isClassDeclaration(stmt) || !t5.isIdentifier(stmt.id, { name: componentClassName }))
+      continue;
+    const templateMethod = stmt.body.body.find(
+      (member) => t5.isClassMethod(member) && t5.isIdentifier(member.key) && member.key.name === "template"
+    );
+    if (!templateMethod || !t5.isBlockStatement(templateMethod.body)) continue;
+    const ret = templateMethod.body.body.find(
+      (node) => t5.isReturnStatement(node) && node.argument && t5.isJSXElement(node.argument)
+    );
+    if (ret && t5.isReturnStatement(ret) && ret.argument && t5.isJSXElement(ret.argument)) {
+      found = {
+        jsx: ret.argument,
+        context: getPropContext(templateMethod.params)
+      };
+      break;
+    }
+  }
+  return found;
+}
+var hoistableRootEventCache = /* @__PURE__ */ new Map();
+function getHoistableRootEventsForImport(importer, source) {
+  const resolved = resolveImportPath(importer, source);
+  if (!resolved) return [];
+  const cached = hoistableRootEventCache.get(resolved);
+  if (cached) return cached;
+  let result;
+  try {
+    const code = readFileSync(resolved, "utf8");
+    const parsed = parseSource(code);
+    if (!parsed) return [];
+    const root = getReturnedRootJSX(parsed.ast, parsed.componentClassName);
+    if (!root) return [];
+    const selector = getRootClassSelector(root.jsx);
+    if (!selector) return [];
+    result = root.jsx.openingElement.attributes.flatMap((attr) => {
+      if (!t5.isJSXAttribute(attr) || !t5.isJSXIdentifier(attr.name)) return [];
+      if (!attr.value || !t5.isJSXExpressionContainer(attr.value) || t5.isJSXEmptyExpression(attr.value.expression)) {
+        return [];
+      }
+      const meta = getHoistableRootEvent(
+        attr.name.name,
+        attr.value.expression,
+        [],
+        root.context,
+        selector
+      );
+      return meta ? [meta] : [];
+    });
+  } catch (err) {
+    console.warn(`[gea] Failed to analyze root events for ${resolved}:`, err instanceof Error ? err.message : err);
+    result = [];
+  }
+  hoistableRootEventCache.set(resolved, result);
+  return result;
+}
+
 // src/analyze-map.ts
-import * as t6 from "@babel/types";
+import * as t7 from "@babel/types";
 
 // src/analyze-helpers.ts
-import * as t5 from "@babel/types";
+import * as t6 from "@babel/types";
 function resolvePropRef(expr, propsParamName, destructuredPropNames) {
-  if (t5.isIdentifier(expr) && destructuredPropNames?.has(expr.name)) return expr.name;
-  if (!t5.isMemberExpression(expr) || !t5.isIdentifier(expr.property)) return null;
+  if (t6.isIdentifier(expr) && destructuredPropNames?.has(expr.name)) return expr.name;
+  if (!t6.isMemberExpression(expr) || !t6.isIdentifier(expr.property)) return null;
   const propName = expr.property.name;
-  if (t5.isMemberExpression(expr.object) && t5.isIdentifier(expr.object.property) && expr.object.property.name === "props") {
+  if (t6.isMemberExpression(expr.object) && t6.isIdentifier(expr.object.property) && expr.object.property.name === "props") {
     const obj = expr.object.object;
-    if (t5.isThisExpression(obj)) return propName;
-    if (t5.isIdentifier(obj) && obj.name === propsParamName) return propName;
+    if (t6.isThisExpression(obj)) return propName;
+    if (t6.isIdentifier(obj) && obj.name === propsParamName) return propName;
   }
-  if (t5.isIdentifier(expr.object) && expr.object.name === (propsParamName || "props")) return propName;
+  if (t6.isIdentifier(expr.object) && expr.object.name === (propsParamName || "props")) return propName;
   return null;
 }
 function resolveExpr(expr, stateRefs) {
-  if (t5.isMemberExpression(expr) && t5.isCallExpression(expr.object) && t5.isMemberExpression(expr.object.callee)) {
+  if (t6.isMemberExpression(expr) && t6.isCallExpression(expr.object) && t6.isMemberExpression(expr.object.callee)) {
     return resolvePath(expr.object.callee.object, stateRefs);
   }
-  if (t5.isMemberExpression(expr) || t5.isIdentifier(expr)) return resolvePath(expr, stateRefs);
-  if (t5.isCallExpression(expr)) {
-    if (t5.isMemberExpression(expr.callee)) {
+  if (t6.isMemberExpression(expr) || t6.isIdentifier(expr)) return resolvePath(expr, stateRefs);
+  if (t6.isCallExpression(expr)) {
+    if (t6.isMemberExpression(expr.callee)) {
       const result = resolvePath(expr.callee.object, stateRefs);
       if (result?.parts?.length) return result;
     }
     for (const arg of expr.arguments) {
-      if (t5.isExpression(arg) && (t5.isMemberExpression(arg) || t5.isIdentifier(arg))) {
+      if (t6.isExpression(arg) && (t6.isMemberExpression(arg) || t6.isIdentifier(arg))) {
         const result = resolvePath(arg, stateRefs);
         if (result?.parts?.length) return result;
       }
     }
   }
-  if (t5.isTemplateLiteral(expr)) {
+  if (t6.isTemplateLiteral(expr)) {
     for (const inner of expr.expressions) {
-      if (t5.isExpression(inner)) {
+      if (t6.isExpression(inner)) {
         const result = resolveExpr(inner, stateRefs);
         if (result?.parts?.length) return result;
       }
@@ -1894,7 +2136,7 @@ function applyImportedState(binding, result, stateProps) {
 function isComputedArrayProp(pathParts, textExpressions, stateRefs) {
   const deps = /* @__PURE__ */ new Set();
   textExpressions.forEach((te) => {
-    if (te.expression && t5.isCallExpression(te.expression) && t5.isMemberExpression(te.expression.callee)) {
+    if (te.expression && t6.isCallExpression(te.expression) && t6.isMemberExpression(te.expression.callee)) {
       const r = resolvePath(te.expression.callee.object, stateRefs);
       if (r?.parts?.length) deps.add(r.parts[0]);
     }
@@ -1905,7 +2147,7 @@ function addArrayTextBindings(selector, tagName, elementPath, bindings, statePro
   const deps = /* @__PURE__ */ new Set();
   textExpressions.forEach((te) => {
     if (te.pathParts.length > 0) deps.add(te.pathParts[0]);
-    if (te.expression && t5.isCallExpression(te.expression) && t5.isMemberExpression(te.expression.callee)) {
+    if (te.expression && t6.isCallExpression(te.expression) && t6.isMemberExpression(te.expression.callee)) {
       const r = resolvePath(te.expression.callee.object, stateRefs);
       if (r?.parts?.length) deps.add(r.parts[0]);
     }
@@ -1931,10 +2173,10 @@ function addArrayTextBindings(selector, tagName, elementPath, bindings, statePro
   });
 }
 function unwrapJSX(expr) {
-  if (t5.isJSXElement(expr)) return expr;
-  if (t5.isJSXFragment(expr)) return expr;
-  if (t5.isParenthesizedExpression(expr) && t5.isJSXElement(expr.expression)) return expr.expression;
-  if (t5.isConditionalExpression(expr)) {
+  if (t6.isJSXElement(expr)) return expr;
+  if (t6.isJSXFragment(expr)) return expr;
+  if (t6.isParenthesizedExpression(expr) && t6.isJSXElement(expr.expression)) return expr.expression;
+  if (t6.isConditionalExpression(expr)) {
     const fromCons = unwrapJSX(expr.consequent);
     if (fromCons) return fromCons;
     return unwrapJSX(expr.alternate);
@@ -1943,14 +2185,14 @@ function unwrapJSX(expr) {
 }
 function normalizeDestructuredMapCallback(arrowFn) {
   const param = arrowFn.params[0];
-  if (!param || t5.isIdentifier(param) || t5.isRestElement(param)) return;
-  if (!t5.isObjectPattern(param) && !t5.isArrayPattern(param)) return;
+  if (!param || t6.isIdentifier(param) || t6.isRestElement(param)) return;
+  if (!t6.isObjectPattern(param) && !t6.isArrayPattern(param)) return;
   const itemName = "__item";
-  if (t5.isArrayPattern(param)) {
+  if (t6.isArrayPattern(param)) {
     const indexMap = /* @__PURE__ */ new Map();
     for (let i = 0; i < param.elements.length; i++) {
       const el = param.elements[i];
-      if (t5.isIdentifier(el)) indexMap.set(el.name, i);
+      if (t6.isIdentifier(el)) indexMap.set(el.name, i);
     }
     if (indexMap.size === 0) return;
     const rewriteNode2 = (node) => {
@@ -1962,12 +2204,12 @@ function normalizeDestructuredMapCallback(arrowFn) {
         if (Array.isArray(child)) {
           for (let i = 0; i < child.length; i++) {
             if (child[i] && typeof child[i] === "object" && child[i].type) {
-              if (t5.isIdentifier(child[i]) && indexMap.has(child[i].name)) {
-                if (t5.isMemberExpression(node) && key === "property" && !node.computed) continue;
-                if (t5.isObjectProperty(node) && key === "key") continue;
-                child[i] = t5.memberExpression(
-                  t5.identifier(itemName),
-                  t5.numericLiteral(indexMap.get(child[i].name)),
+              if (t6.isIdentifier(child[i]) && indexMap.has(child[i].name)) {
+                if (t6.isMemberExpression(node) && key === "property" && !node.computed) continue;
+                if (t6.isObjectProperty(node) && key === "key") continue;
+                child[i] = t6.memberExpression(
+                  t6.identifier(itemName),
+                  t6.numericLiteral(indexMap.get(child[i].name)),
                   true
                 );
               } else {
@@ -1976,12 +2218,12 @@ function normalizeDestructuredMapCallback(arrowFn) {
             }
           }
         } else if (child && typeof child === "object" && child.type) {
-          if (t5.isIdentifier(child) && indexMap.has(child.name)) {
-            if (t5.isMemberExpression(node) && key === "property" && !node.computed) continue;
-            if (t5.isObjectProperty(node) && key === "key") continue;
-            node[key] = t5.memberExpression(
-              t5.identifier(itemName),
-              t5.numericLiteral(indexMap.get(child.name)),
+          if (t6.isIdentifier(child) && indexMap.has(child.name)) {
+            if (t6.isMemberExpression(node) && key === "property" && !node.computed) continue;
+            if (t6.isObjectProperty(node) && key === "key") continue;
+            node[key] = t6.memberExpression(
+              t6.identifier(itemName),
+              t6.numericLiteral(indexMap.get(child.name)),
               true
             );
           } else {
@@ -1991,14 +2233,14 @@ function normalizeDestructuredMapCallback(arrowFn) {
       }
     };
     rewriteNode2(arrowFn.body);
-    arrowFn.params[0] = t5.identifier(itemName);
+    arrowFn.params[0] = t6.identifier(itemName);
     return;
   }
   const nameMap = /* @__PURE__ */ new Map();
   for (const prop of param.properties) {
-    if (t5.isObjectProperty(prop)) {
-      const keyName = t5.isIdentifier(prop.key) ? prop.key.name : t5.isStringLiteral(prop.key) ? prop.key.value : null;
-      const valueName = t5.isIdentifier(prop.value) ? prop.value.name : null;
+    if (t6.isObjectProperty(prop)) {
+      const keyName = t6.isIdentifier(prop.key) ? prop.key.name : t6.isStringLiteral(prop.key) ? prop.key.value : null;
+      const valueName = t6.isIdentifier(prop.value) ? prop.value.name : null;
       if (keyName && valueName) nameMap.set(valueName, keyName);
     }
   }
@@ -2012,20 +2254,20 @@ function normalizeDestructuredMapCallback(arrowFn) {
       if (Array.isArray(child)) {
         for (let i = 0; i < child.length; i++) {
           if (child[i] && typeof child[i] === "object" && child[i].type) {
-            if (t5.isIdentifier(child[i]) && nameMap.has(child[i].name)) {
-              if (t5.isMemberExpression(node) && key === "property" && !node.computed) continue;
-              if (t5.isObjectProperty(node) && key === "key") continue;
-              child[i] = t5.memberExpression(t5.identifier(itemName), t5.identifier(nameMap.get(child[i].name)));
+            if (t6.isIdentifier(child[i]) && nameMap.has(child[i].name)) {
+              if (t6.isMemberExpression(node) && key === "property" && !node.computed) continue;
+              if (t6.isObjectProperty(node) && key === "key") continue;
+              child[i] = t6.memberExpression(t6.identifier(itemName), t6.identifier(nameMap.get(child[i].name)));
             } else {
               rewriteNode(child[i]);
             }
           }
         }
       } else if (child && typeof child === "object" && child.type) {
-        if (t5.isIdentifier(child) && nameMap.has(child.name)) {
-          if (t5.isMemberExpression(node) && key === "property" && !node.computed) continue;
-          if (t5.isObjectProperty(node) && key === "key") continue;
-          node[key] = t5.memberExpression(t5.identifier(itemName), t5.identifier(nameMap.get(child.name)));
+        if (t6.isIdentifier(child) && nameMap.has(child.name)) {
+          if (t6.isMemberExpression(node) && key === "property" && !node.computed) continue;
+          if (t6.isObjectProperty(node) && key === "key") continue;
+          node[key] = t6.memberExpression(t6.identifier(itemName), t6.identifier(nameMap.get(child.name)));
         } else {
           rewriteNode(child);
         }
@@ -2033,29 +2275,29 @@ function normalizeDestructuredMapCallback(arrowFn) {
     }
   };
   rewriteNode(arrowFn.body);
-  arrowFn.params[0] = t5.identifier(itemName);
+  arrowFn.params[0] = t6.identifier(itemName);
 }
 function extractItemTemplate(arrowFn) {
   let body;
-  if (t5.isJSXElement(arrowFn.body) || t5.isJSXFragment(arrowFn.body)) body = arrowFn.body;
-  else if (t5.isParenthesizedExpression(arrowFn.body)) body = arrowFn.body.expression;
-  else if (t5.isBlockStatement(arrowFn.body)) {
-    const returnStmt = arrowFn.body.body.find((s) => t5.isReturnStatement(s));
+  if (t6.isJSXElement(arrowFn.body) || t6.isJSXFragment(arrowFn.body)) body = arrowFn.body;
+  else if (t6.isParenthesizedExpression(arrowFn.body)) body = arrowFn.body.expression;
+  else if (t6.isBlockStatement(arrowFn.body)) {
+    const returnStmt = arrowFn.body.body.find((s) => t6.isReturnStatement(s));
     body = returnStmt?.argument;
-  } else if (t5.isConditionalExpression(arrowFn.body)) body = arrowFn.body;
+  } else if (t6.isConditionalExpression(arrowFn.body)) body = arrowFn.body;
   return body ? unwrapJSX(body) : void 0;
 }
 function extractCallbackBodyStatements(arrowFn) {
-  if (!t5.isBlockStatement(arrowFn.body)) return [];
+  if (!t6.isBlockStatement(arrowFn.body)) return [];
   const stmts = [];
   for (const s of arrowFn.body.body) {
-    if (t5.isReturnStatement(s) && s.argument) {
-      if (t5.isJSXElement(s.argument) || t5.isJSXFragment(s.argument) || t5.isParenthesizedExpression(s.argument)) {
+    if (t6.isReturnStatement(s) && s.argument) {
+      if (t6.isJSXElement(s.argument) || t6.isJSXFragment(s.argument) || t6.isParenthesizedExpression(s.argument)) {
         break;
       }
-      stmts.push(t5.returnStatement(t5.stringLiteral("")));
+      stmts.push(t6.returnStatement(t6.stringLiteral("")));
     } else {
-      const cloned = t5.cloneNode(s, true);
+      const cloned = t6.cloneNode(s, true);
       rewriteEarlyReturns(cloned);
       stmts.push(cloned);
     }
@@ -2063,18 +2305,18 @@ function extractCallbackBodyStatements(arrowFn) {
   return stmts;
 }
 function rewriteEarlyReturns(node) {
-  if (t5.isIfStatement(node)) {
-    if (t5.isReturnStatement(node.consequent)) {
-      if (!node.consequent.argument || t5.isNullLiteral(node.consequent.argument) || t5.isIdentifier(node.consequent.argument) && node.consequent.argument.name === "undefined") {
-        node.consequent = t5.returnStatement(t5.stringLiteral(""));
+  if (t6.isIfStatement(node)) {
+    if (t6.isReturnStatement(node.consequent)) {
+      if (!node.consequent.argument || t6.isNullLiteral(node.consequent.argument) || t6.isIdentifier(node.consequent.argument) && node.consequent.argument.name === "undefined") {
+        node.consequent = t6.returnStatement(t6.stringLiteral(""));
       }
-    } else if (t5.isBlockStatement(node.consequent)) {
+    } else if (t6.isBlockStatement(node.consequent)) {
       node.consequent.body.forEach(rewriteEarlyReturns);
     }
     if (node.alternate) {
-      if (t5.isReturnStatement(node.alternate)) {
-        if (!node.alternate.argument || t5.isNullLiteral(node.alternate.argument) || t5.isIdentifier(node.alternate.argument) && node.alternate.argument.name === "undefined") {
-          node.alternate = t5.returnStatement(t5.stringLiteral(""));
+      if (t6.isReturnStatement(node.alternate)) {
+        if (!node.alternate.argument || t6.isNullLiteral(node.alternate.argument) || t6.isIdentifier(node.alternate.argument) && node.alternate.argument.name === "undefined") {
+          node.alternate = t6.returnStatement(t6.stringLiteral(""));
         }
       } else {
         rewriteEarlyReturns(node.alternate);
@@ -2086,42 +2328,42 @@ var ITEM_IS_KEY = "__self__";
 function getItemMemberPath(expr, itemVar) {
   const parts = [];
   let current = expr;
-  while (t5.isMemberExpression(current) && !current.computed && t5.isIdentifier(current.property)) {
+  while (t6.isMemberExpression(current) && !current.computed && t6.isIdentifier(current.property)) {
     parts.unshift(current.property.name);
     current = current.object;
   }
-  if (!t5.isIdentifier(current) || current.name !== itemVar || parts.length === 0) return void 0;
+  if (!t6.isIdentifier(current) || current.name !== itemVar || parts.length === 0) return void 0;
   return parts.join(".");
 }
 function detectItemIdProperty(template, itemVar) {
-  if (!template || !t5.isJSXElement(template)) return void 0;
+  if (!template || !t6.isJSXElement(template)) return void 0;
   for (const attr of template.openingElement.attributes) {
-    if (!t5.isJSXAttribute(attr) || !t5.isJSXIdentifier(attr.name) || attr.name.name !== "key") continue;
-    if (!t5.isJSXExpressionContainer(attr.value)) continue;
+    if (!t6.isJSXAttribute(attr) || !t6.isJSXIdentifier(attr.name) || attr.name.name !== "key") continue;
+    if (!t6.isJSXExpressionContainer(attr.value)) continue;
     const keyExpr = attr.value.expression;
     const memberPath = getItemMemberPath(keyExpr, itemVar);
     if (memberPath) return memberPath;
-    if (t5.isIdentifier(keyExpr) && keyExpr.name === itemVar) return ITEM_IS_KEY;
+    if (t6.isIdentifier(keyExpr) && keyExpr.name === itemVar) return ITEM_IS_KEY;
   }
   return void 0;
 }
 function hasExplicitItemKey(template) {
-  if (!template || !t5.isJSXElement(template)) return false;
+  if (!template || !t6.isJSXElement(template)) return false;
   return template.openingElement.attributes.some(
-    (attr) => t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name) && attr.name.name === "key"
+    (attr) => t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name) && attr.name.name === "key"
   );
 }
 function hasRootUserIdAttribute(template) {
-  if (!template || !t5.isJSXElement(template)) return false;
+  if (!template || !t6.isJSXElement(template)) return false;
   return template.openingElement.attributes.some(
-    (attr) => t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name) && attr.name.name === "id"
+    (attr) => t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name) && attr.name.name === "id"
   );
 }
 function detectContainerSelector(node, tagName) {
   for (const attr of node.openingElement.attributes) {
-    if (!t5.isJSXAttribute(attr) || !t5.isJSXIdentifier(attr.name)) continue;
-    if (attr.name.name === "class" && t5.isStringLiteral(attr.value)) return `.${attr.value.value.split(" ")[0]}`;
-    if (attr.name.name === "id" && t5.isStringLiteral(attr.value)) return `#${attr.value.value}`;
+    if (!t6.isJSXAttribute(attr) || !t6.isJSXIdentifier(attr.name)) continue;
+    if (attr.name.name === "class" && t6.isStringLiteral(attr.value)) return `.${attr.value.value.split(" ")[0]}`;
+    if (attr.name.name === "id" && t6.isStringLiteral(attr.value)) return `#${attr.value.value}`;
   }
   return tagName;
 }
@@ -2133,21 +2375,21 @@ var traverse3 = require4("@babel/traverse").default;
 function getItemMemberPath2(expr, itemVar) {
   const parts = [];
   let current = expr;
-  while (t6.isMemberExpression(current) && !current.computed && t6.isIdentifier(current.property)) {
+  while (t7.isMemberExpression(current) && !current.computed && t7.isIdentifier(current.property)) {
     parts.unshift(current.property.name);
     current = current.object;
   }
-  if (!t6.isIdentifier(current) || current.name !== itemVar || parts.length === 0) return null;
+  if (!t7.isIdentifier(current) || current.name !== itemVar || parts.length === 0) return null;
   return parts.join(".");
 }
 function analyzeJSXInMap(node, arrayPath, itemVar, itemBindings, relationalBindings, conditionalBindings, elementPath, isImportedState, itemIdProperty, stateRefs, childIndices = [], storeVar) {
   const context = { inMap: true, mapItemVar: itemVar };
   node.openingElement.attributes.forEach((attr) => {
-    if (!t6.isJSXAttribute(attr) || !t6.isJSXIdentifier(attr.name)) return;
+    if (!t7.isJSXAttribute(attr) || !t7.isJSXIdentifier(attr.name)) return;
     const attrName = attr.name.name;
-    if (!attr.value || !t6.isJSXExpressionContainer(attr.value)) return;
+    if (!attr.value || !t7.isJSXExpressionContainer(attr.value)) return;
     const expr = attr.value.expression;
-    if (t6.isMemberExpression(expr)) {
+    if (t7.isMemberExpression(expr)) {
       analyzeItemMemberExpr(
         expr,
         attrName,
@@ -2162,7 +2404,7 @@ function analyzeJSXInMap(node, arrayPath, itemVar, itemBindings, relationalBindi
         context,
         childIndices
       );
-    } else if (t6.isConditionalExpression(expr)) {
+    } else if (t7.isConditionalExpression(expr)) {
       const isClassAttr = attrName === "class" || attrName === "className";
       analyzeItemConditional(
         expr,
@@ -2181,7 +2423,7 @@ function analyzeJSXInMap(node, arrayPath, itemVar, itemBindings, relationalBindi
         storeVar,
         isClassAttr
       );
-    } else if (t6.isTemplateLiteral(expr)) {
+    } else if (t7.isTemplateLiteral(expr)) {
       analyzeItemTemplateLiteral(
         expr,
         arrayPath,
@@ -2200,8 +2442,8 @@ function analyzeJSXInMap(node, arrayPath, itemVar, itemBindings, relationalBindi
     }
   });
   node.children.forEach((child) => {
-    if (t6.isJSXExpressionContainer(child) && !t6.isJSXEmptyExpression(child.expression)) {
-      if (t6.isMemberExpression(child.expression)) {
+    if (t7.isJSXExpressionContainer(child) && !t7.isJSXEmptyExpression(child.expression)) {
+      if (t7.isMemberExpression(child.expression)) {
         const propPathResult = resolvePath(child.expression, stateRefs, context);
         if (propPathResult?.parts?.length === 1 && propPathResult.parts[0] !== "id") {
           const wildcardPath = [...arrayPath, "*", propPathResult.parts[0]];
@@ -2215,7 +2457,7 @@ function analyzeJSXInMap(node, arrayPath, itemVar, itemBindings, relationalBindi
           };
           itemBindings.push(binding);
         }
-      } else if (t6.isConditionalExpression(child.expression)) {
+      } else if (t7.isConditionalExpression(child.expression)) {
         collectConditionalBindings(
           child.expression,
           "text",
@@ -2272,8 +2514,8 @@ function analyzeItemConditional(expr, attrName, arrayPath, itemVar, itemBindings
     return;
   }
   const isClassAttribute = attrName === "class" || attrName === "className";
-  if (isClassAttribute && t6.isMemberExpression(expr.test) && t6.isIdentifier(expr.test.object) && expr.test.object.name === itemVar) {
-    const propName = t6.isIdentifier(expr.test.property) ? expr.test.property.name : null;
+  if (isClassAttribute && t7.isMemberExpression(expr.test) && t7.isIdentifier(expr.test.object) && expr.test.object.name === itemVar) {
+    const propName = t7.isIdentifier(expr.test.property) ? expr.test.property.name : null;
     if (!propName) return;
     const detectedClassName = extractClassName(expr.consequent) || extractClassName(expr.alternate);
     const wildcardPath = [...arrayPath, "*", propName];
@@ -2291,7 +2533,7 @@ function analyzeItemConditional(expr, attrName, arrayPath, itemVar, itemBindings
     itemBindings.push(binding);
     return;
   }
-  if (isClassAttribute && t6.isBinaryExpression(expr.test) && (expr.test.operator === "===" || expr.test.operator === "==")) {
+  if (isClassAttribute && t7.isBinaryExpression(expr.test) && (expr.test.operator === "===" || expr.test.operator === "==")) {
     const detectedClassName = extractClassName(expr.consequent) || extractClassName(expr.alternate);
     if (!detectedClassName) return;
     const binding = {
@@ -2323,7 +2565,7 @@ function analyzeItemConditional(expr, attrName, arrayPath, itemVar, itemBindings
 }
 function analyzeItemTemplateLiteral(expr, arrayPath, itemVar, itemBindings, relationalBindings, conditionalBindings, elementPath, isImportedState, itemIdProperty, node, stateRefs, childIndices = [], storeVar) {
   expr.expressions.forEach((innerExpr) => {
-    if (!t6.isConditionalExpression(innerExpr)) return;
+    if (!t7.isConditionalExpression(innerExpr)) return;
     analyzeItemConditional(
       innerExpr,
       "class",
@@ -2345,13 +2587,13 @@ function analyzeItemTemplateLiteral(expr, arrayPath, itemVar, itemBindings, rela
 function collectConditionalBindings(expr, type, attributeName, conditionalBindings, arrayPath, itemVar, elementPath, childPath, stateRefs, storeVar) {
   const dependencies = /* @__PURE__ */ new Map();
   const requiresRerender = conditionalExpressionRequiresRerender(expr);
-  const program12 = t6.program([t6.expressionStatement(t6.cloneNode(expr, true))]);
+  const program12 = t7.program([t7.expressionStatement(t7.cloneNode(expr, true))]);
   traverse3(program12, {
     noScope: true,
     MemberExpression(path) {
       const parent = path.parentPath;
-      if (parent && t6.isMemberExpression(parent.node) && parent.node.object === path.node) return;
-      if (t6.isIdentifier(path.node.object) && path.node.object.name === itemVar && t6.isIdentifier(path.node.property)) {
+      if (parent && t7.isMemberExpression(parent.node) && parent.node.object === path.node) return;
+      if (t7.isIdentifier(path.node.object) && path.node.object.name === itemVar && t7.isIdentifier(path.node.property)) {
         const pathParts = [...arrayPath];
         const observeKey2 = buildObserveKey(pathParts, storeVar);
         if (!dependencies.has(observeKey2)) {
@@ -2382,14 +2624,14 @@ function collectConditionalBindings(expr, type, attributeName, conditionalBindin
       childPath: [...childPath],
       selector: generateSelector(elementPath),
       attributeName,
-      expression: t6.cloneNode(expr, true),
+      expression: t7.cloneNode(expr, true),
       requiresRerender
     });
   });
 }
 function conditionalExpressionRequiresRerender(expr) {
   let needsRerender = false;
-  const program12 = t6.program([t6.expressionStatement(t6.cloneNode(expr, true))]);
+  const program12 = t7.program([t7.expressionStatement(t7.cloneNode(expr, true))]);
   traverse3(program12, {
     noScope: true,
     JSXElement(path) {
@@ -2435,7 +2677,7 @@ function buildRelationalClassBinding(expr, elementPath, itemVar, itemIdProperty,
   return null;
 }
 function resolveExternalIdentityPredicate(test, itemVar, itemIdProperty, stateRefs) {
-  if (!t6.isBinaryExpression(test)) return null;
+  if (!t7.isBinaryExpression(test)) return null;
   if (!["===", "==", "!==", "!="].includes(test.operator)) return null;
   const left = resolveSide(test.left, itemVar, itemIdProperty, stateRefs);
   const right = resolveSide(test.right, itemVar, itemIdProperty, stateRefs);
@@ -2450,13 +2692,13 @@ function resolveExternalIdentityPredicate(test, itemVar, itemIdProperty, stateRe
   };
 }
 function resolveSide(expr, itemVar, itemIdProperty, stateRefs) {
-  if (itemIdProperty === ITEM_IS_KEY && t6.isIdentifier(expr) && expr.name === itemVar) {
+  if (itemIdProperty === ITEM_IS_KEY && t7.isIdentifier(expr) && expr.name === itemVar) {
     return { kind: "item-id" };
   }
   if (getItemMemberPath2(expr, itemVar) === itemIdProperty) {
     return { kind: "item-id" };
   }
-  if (!t6.isMemberExpression(expr) && !t6.isIdentifier(expr)) return null;
+  if (!t7.isMemberExpression(expr) && !t7.isIdentifier(expr)) return null;
   const resolved = resolvePath(expr, stateRefs);
   if (!resolved?.parts) return null;
   if (resolved.parts[0] === itemVar) return null;
@@ -2467,14 +2709,14 @@ function resolveSide(expr, itemVar, itemIdProperty, stateRefs) {
   };
 }
 function isEmptyBranch(node) {
-  return t6.isStringLiteral(node) && node.value.trim() === "" || t6.isTemplateLiteral(node) && node.expressions.length === 0 && node.quasis.every((q) => q.value.raw.trim() === "");
+  return t7.isStringLiteral(node) && node.value.trim() === "" || t7.isTemplateLiteral(node) && node.expressions.length === 0 && node.quasis.every((q) => q.value.raw.trim() === "");
 }
 function extractClassName(node) {
-  if (t6.isStringLiteral(node)) {
+  if (t7.isStringLiteral(node)) {
     const cls = node.value.trim();
     return cls ? cls.split(" ")[0] : void 0;
   }
-  if (t6.isTemplateLiteral(node)) {
+  if (t7.isTemplateLiteral(node)) {
     const raw = node.quasis[0]?.value.raw.trim();
     return raw ? raw.split(" ")[0] : void 0;
   }
@@ -2482,7 +2724,7 @@ function extractClassName(node) {
 }
 
 // src/transform-attributes.ts
-import * as t7 from "@babel/types";
+import * as t8 from "@babel/types";
 import { createRequire as createRequire4 } from "module";
 var require5 = createRequire4(import.meta.url);
 var traverse4 = require5("@babel/traverse").default;
@@ -2490,35 +2732,35 @@ function buildComponentPropsExpression(jsxElement, imports, componentInstances,
   const props = [];
   const dependencies = /* @__PURE__ */ new Map();
   jsxElement.openingElement.attributes.forEach((attr) => {
-    if (!t7.isJSXAttribute(attr) || !t7.isJSXIdentifier(attr.name) || attr.name.name === "key") return;
+    if (!t8.isJSXAttribute(attr) || !t8.isJSXIdentifier(attr.name) || attr.name.name === "key") return;
     const propName = attr.name.name;
     let propValue = null;
-    if (attr.value === null) propValue = t7.booleanLiteral(true);
-    else if (t7.isStringLiteral(attr.value)) propValue = t7.stringLiteral(attr.value.value);
-    else if (t7.isJSXExpressionContainer(attr.value) && !t7.isJSXEmptyExpression(attr.value.expression)) {
+    if (attr.value === null) propValue = t8.booleanLiteral(true);
+    else if (t8.isStringLiteral(attr.value)) propValue = t8.stringLiteral(attr.value.value);
+    else if (t8.isJSXExpressionContainer(attr.value) && !t8.isJSXEmptyExpression(attr.value.expression)) {
       const expr = attr.value.expression;
       propValue = transformExpression(expr);
       if (propValue && (/^on[A-Z]/.test(propName) || /^(click|input|change|submit|focus|blur|keydown|keyup|keypress|mousedown|mouseup|mouseover|mouseout|mouseenter|mouseleave|touchstart|touchend|touchmove|pointerdown|pointerup|pointermove|scroll|resize|drag|dragstart|dragend|dragover|drop|reset)$/.test(
         propName
-      )) && t7.isMemberExpression(propValue)) {
-        const argsId = t7.identifier("args");
-        propValue = t7.arrowFunctionExpression(
-          [t7.restElement(argsId)],
-          t7.callExpression(t7.cloneNode(propValue, true), [t7.spreadElement(argsId)])
+      )) && t8.isMemberExpression(propValue)) {
+        const argsId = t8.identifier("args");
+        propValue = t8.arrowFunctionExpression(
+          [t8.restElement(argsId)],
+          t8.callExpression(t8.cloneNode(propValue, true), [t8.spreadElement(argsId)])
         );
       }
     }
     if (propValue) {
-      const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName) ? t7.identifier(propName) : t7.stringLiteral(propName);
-      props.push(t7.objectProperty(key, propValue));
+      const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName) ? t8.identifier(propName) : t8.stringLiteral(propName);
+      props.push(t8.objectProperty(key, propValue));
     }
   });
-  const meaningfulChildren = jsxElement.children.filter((c) => !(t7.isJSXText(c) && c.value.trim() === ""));
+  const meaningfulChildren = jsxElement.children.filter((c) => !(t8.isJSXText(c) && c.value.trim() === ""));
   if (meaningfulChildren.length > 0) {
-    const frag = t7.jsxFragment(t7.jsxOpeningFragment(), t7.jsxClosingFragment(), meaningfulChildren);
-    props.push(t7.objectProperty(t7.identifier("children"), transformFragment(frag)));
+    const frag = t8.jsxFragment(t8.jsxOpeningFragment(), t8.jsxClosingFragment(), meaningfulChildren);
+    props.push(t8.objectProperty(t8.identifier("children"), transformFragment(frag)));
   }
-  const expression = t7.objectExpression(props);
+  const expression = t8.objectExpression(props);
   const setupStatements = collectTemplateSetupStatements(expression, templateSetupContext);
   collectExpressionDependenciesInto(expression, stateRefs, dependencies, setupStatements);
   return { expression, dependencies: Array.from(dependencies.values()), setupStatements };
@@ -2542,18 +2784,18 @@ function collectExpressionDependenciesInto(expr, stateRefs, dependencies, setupS
   };
   const referencedNames = collectReferencedIdentifiers(expr);
   setupStatements.forEach((statement) => {
-    if (!t7.isVariableDeclaration(statement)) return;
+    if (!t8.isVariableDeclaration(statement)) return;
     statement.declarations.forEach((declaration) => {
-      if (!t7.isObjectPattern(declaration.id) || !declaration.init) return;
+      if (!t8.isObjectPattern(declaration.id) || !declaration.init) return;
       const resolved = resolvePath(declaration.init, stateRefs);
       if (!resolved?.parts) return;
       declaration.id.properties.forEach((property) => {
-        if (!t7.isObjectProperty(property)) return;
-        const keyName = t7.isIdentifier(property.key) ? property.key.name : t7.isStringLiteral(property.key) ? property.key.value : null;
+        if (!t8.isObjectProperty(property)) return;
+        const keyName = t8.isIdentifier(property.key) ? property.key.name : t8.isStringLiteral(property.key) ? property.key.value : null;
         if (!keyName) return;
         const valueNames = collectPatternIdentifiers(property.value);
         if (!valueNames.some((name) => referencedNames.has(name))) return;
-        const isStoreInstanceDestructure = resolved.isImportedState && resolved.parts.length === 0 && t7.isIdentifier(declaration.init);
+        const isStoreInstanceDestructure = resolved.isImportedState && resolved.parts.length === 0 && t8.isIdentifier(declaration.init);
         if (isStoreInstanceDestructure) {
           const storeRef = stateRefs.get(declaration.init.name);
           const getterStatePaths = storeRef?.getterDeps?.get(keyName);
@@ -2572,18 +2814,18 @@ function collectExpressionDependenciesInto(expr, stateRefs, dependencies, setupS
       });
     });
   });
-  const program12 = t7.program([
-    ...setupStatements.map((statement) => t7.cloneNode(statement, true)),
-    t7.expressionStatement(t7.cloneNode(expr, true))
+  const program12 = t8.program([
+    ...setupStatements.map((statement) => t8.cloneNode(statement, true)),
+    t8.expressionStatement(t8.cloneNode(expr, true))
   ]);
   traverse4(program12, {
     noScope: true,
     MemberExpression(path) {
       const parent = path.parentPath;
-      if (parent && t7.isMemberExpression(parent.node) && parent.node.object === path.node) return;
+      if (parent && t8.isMemberExpression(parent.node) && parent.node.object === path.node) return;
       const resolved = resolvePath(path.node, stateRefs);
       if (!resolved?.parts?.length) return;
-      const isMethodCall = parent && t7.isCallExpression(parent.node) && parent.node.callee === path.node;
+      const isMethodCall = parent && t8.isCallExpression(parent.node) && parent.node.callee === path.node;
       if (isMethodCall && resolved.isImportedState && resolved.storeVar) {
         const ref = stateRefs?.get(resolved.storeVar);
         if (ref && !ref.reactiveFields) {
@@ -2622,12 +2864,12 @@ function collectTemplateSetupStatements(expr, templateSetupContext) {
   if (!templateSetupContext) return [];
   const bindingMap = /* @__PURE__ */ new Map();
   const firstParam = templateSetupContext.params[0];
-  const paramBinding = firstParam && !t7.isRestElement(firstParam) ? getTemplateParamBinding(firstParam) : void 0;
+  const paramBinding = firstParam && !t8.isRestElement(firstParam) ? getTemplateParamBinding(firstParam) : void 0;
   if (paramBinding) {
-    const paramStatement = t7.variableDeclaration("const", [
-      t7.variableDeclarator(
-        t7.cloneNode(paramBinding, true),
-        t7.memberExpression(t7.thisExpression(), t7.identifier("props"))
+    const paramStatement = t8.variableDeclaration("const", [
+      t8.variableDeclarator(
+        t8.cloneNode(paramBinding, true),
+        t8.memberExpression(t8.thisExpression(), t8.identifier("props"))
       )
     ]);
     collectPatternIdentifiers(paramBinding).forEach((name) => {
@@ -2652,7 +2894,7 @@ function collectTemplateSetupStatements(expr, templateSetupContext) {
     if (binding.index === -1) includedParamNames.add(name);
     if (!included.has(binding.index)) {
       included.add(binding.index);
-      ordered.push({ index: binding.index, statement: t7.cloneNode(binding.statement, true) });
+      ordered.push({ index: binding.index, statement: t8.cloneNode(binding.statement, true) });
     }
   };
   collectReferencedIdentifiers(expr).forEach(includeName);
@@ -2670,7 +2912,7 @@ function collectTemplateSetupStatements(expr, templateSetupContext) {
           if (!have.has(bi)) {
             extra.push({
               index: bi,
-              statement: t7.cloneNode(templateSetupContext.statements[bi], true)
+              statement: t8.cloneNode(templateSetupContext.statements[bi], true)
             });
           }
         }
@@ -2681,13 +2923,13 @@ function collectTemplateSetupStatements(expr, templateSetupContext) {
   }
   for (const entry of ordered) {
     if (entry.index !== -1) continue;
-    if (!t7.isVariableDeclaration(entry.statement)) continue;
+    if (!t8.isVariableDeclaration(entry.statement)) continue;
     const decl = entry.statement.declarations[0];
-    if (!t7.isObjectPattern(decl.id)) continue;
+    if (!t8.isObjectPattern(decl.id)) continue;
     decl.id.properties = decl.id.properties.filter((prop) => {
-      if (t7.isRestElement(prop)) return true;
-      if (t7.isObjectProperty(prop)) {
-        const keyName = t7.isIdentifier(prop.key) ? prop.key.name : t7.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (t8.isRestElement(prop)) return true;
+      if (t8.isObjectProperty(prop)) {
+        const keyName = t8.isIdentifier(prop.key) ? prop.key.name : t8.isStringLiteral(prop.key) ? prop.key.value : null;
         return keyName ? includedParamNames.has(keyName) : true;
       }
       return true;
@@ -2696,36 +2938,36 @@ function collectTemplateSetupStatements(expr, templateSetupContext) {
   return ordered.map((entry) => entry.statement);
 }
 function collectStatementBindingNames(statement) {
-  if (t7.isVariableDeclaration(statement)) {
+  if (t8.isVariableDeclaration(statement)) {
     return statement.declarations.flatMap((declaration) => collectPatternIdentifiers(declaration.id));
   }
-  if (t7.isFunctionDeclaration(statement) && statement.id) {
+  if (t8.isFunctionDeclaration(statement) && statement.id) {
     return [statement.id.name];
   }
-  if (t7.isClassDeclaration(statement) && statement.id) {
+  if (t8.isClassDeclaration(statement) && statement.id) {
     return [statement.id.name];
   }
   return [];
 }
 function collectPatternIdentifiers(pattern) {
-  if (t7.isIdentifier(pattern)) return [pattern.name];
-  if (t7.isRestElement(pattern)) return collectPatternIdentifiers(pattern.argument);
-  if (t7.isAssignmentPattern(pattern)) return collectPatternIdentifiers(pattern.left);
-  if (t7.isObjectPattern(pattern)) {
+  if (t8.isIdentifier(pattern)) return [pattern.name];
+  if (t8.isRestElement(pattern)) return collectPatternIdentifiers(pattern.argument);
+  if (t8.isAssignmentPattern(pattern)) return collectPatternIdentifiers(pattern.left);
+  if (t8.isObjectPattern(pattern)) {
     return pattern.properties.flatMap((property) => {
-      if (t7.isRestElement(property)) return collectPatternIdentifiers(property.argument);
+      if (t8.isRestElement(property)) return collectPatternIdentifiers(property.argument);
       return collectPatternIdentifiers(property.value);
     });
   }
-  if (t7.isArrayPattern(pattern)) {
+  if (t8.isArrayPattern(pattern)) {
     return pattern.elements.flatMap((element) => element ? collectPatternIdentifiers(element) : []);
   }
   return [];
 }
 function collectReferencedIdentifiers(node) {
   const names = /* @__PURE__ */ new Set();
-  const program12 = t7.program([
-    t7.isStatement(node) ? t7.cloneNode(node, true) : t7.expressionStatement(t7.cloneNode(node, true))
+  const program12 = t8.program([
+    t8.isStatement(node) ? t8.cloneNode(node, true) : t8.expressionStatement(t8.cloneNode(node, true))
   ]);
   traverse4(program12, {
     noScope: true,
@@ -2748,18 +2990,18 @@ function buildTextTemplateExpressionFromParts(textTemplate, textExpressions) {
   for (let i = 0; i < templateParts.length; i++) {
     if (i % 2 === 0) {
       const raw = templateParts[i] || "";
-      quasis.push(t8.templateElement({ raw, cooked: raw }, i === templateParts.length - 1));
+      quasis.push(t9.templateElement({ raw, cooked: raw }, i === templateParts.length - 1));
       continue;
     }
     const idx = Number.parseInt(templateParts[i] || "-1", 10);
     const textExpr = textExpressions[idx];
     if (textExpr?.expression) {
-      expressions.push(t8.cloneNode(textExpr.expression, true));
+      expressions.push(t9.cloneNode(textExpr.expression, true));
     } else {
-      expressions.push(t8.identifier("undefined"));
+      expressions.push(t9.identifier("undefined"));
     }
   }
-  return t8.templateLiteral(quasis, expressions);
+  return t9.templateLiteral(quasis, expressions);
 }
 function assignBindingIds(bindings, propBindings, unresolvedMaps, arrayMaps) {
   const pathToId = /* @__PURE__ */ new Map();
@@ -2809,16 +3051,16 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
   const destructuredPropNames = /* @__PURE__ */ new Set();
   const binding = getTemplateParamBinding(templateMethod.params[0]);
   if (binding) {
-    if (t8.isIdentifier(binding)) propsParamName = binding.name;
+    if (t9.isIdentifier(binding)) propsParamName = binding.name;
     else {
       propsParamName = "props";
       for (const prop of binding.properties) {
-        if (t8.isObjectProperty(prop) && t8.isIdentifier(prop.key) && !prop.computed)
+        if (t9.isObjectProperty(prop) && t9.isIdentifier(prop.key) && !prop.computed)
           destructuredPropNames.add(prop.key.name);
       }
     }
   }
-  if (!templateMethod.body || !t8.isBlockStatement(templateMethod.body))
+  if (!templateMethod.body || !t9.isBlockStatement(templateMethod.body))
     return {
       bindings,
       propBindings,
@@ -2835,7 +3077,7 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
       conditionalSlotNodeMap: /* @__PURE__ */ new Map()
     };
   const bodyStmts = templateMethod.body.body;
-  const returnStmt = bodyStmts.find((s) => t8.isReturnStatement(s) && s.argument !== null);
+  const returnStmt = bodyStmts.find((s) => t9.isReturnStatement(s) && s.argument !== null);
   if (!returnStmt?.argument)
     return {
       bindings,
@@ -2856,49 +3098,49 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
   let earlyReturnGuard;
   let earlyReturnBarrierIndex;
   const earlyReturnFromIf = (s) => {
-    if (t8.isReturnStatement(s.consequent) && s.consequent.argument) return s.consequent;
-    if (t8.isBlockStatement(s.consequent) && s.consequent.body.length === 1 && t8.isReturnStatement(s.consequent.body[0]) && s.consequent.body[0].argument) {
+    if (t9.isReturnStatement(s.consequent) && s.consequent.argument) return s.consequent;
+    if (t9.isBlockStatement(s.consequent) && s.consequent.body.length === 1 && t9.isReturnStatement(s.consequent.body[0]) && s.consequent.body[0].argument) {
       return s.consequent.body[0];
     }
     return null;
   };
   for (let i = 0; i < returnIndex; i++) {
     const s = bodyStmts[i];
-    if (!t8.isIfStatement(s) || s.alternate) continue;
+    if (!t9.isIfStatement(s) || s.alternate) continue;
     const earlyRet = earlyReturnFromIf(s);
     if (!earlyRet?.argument) continue;
-    earlyReturnGuard = t8.cloneNode(s.test, true);
+    earlyReturnGuard = t9.cloneNode(s.test, true);
     earlyReturnBarrierIndex = i;
     break;
   }
   const templateSetupContext = {
     params: templateMethod.params.filter(
-      (param) => !t8.isTSParameterProperty(param)
+      (param) => !t9.isTSParameterProperty(param)
     ),
     statements: returnIndex >= 0 ? templateMethod.body.body.slice(0, returnIndex) : []
   };
-  const templateRoot = t8.isJSXElement(returnStmt.argument) ? returnStmt.argument : null;
+  const templateRoot = t9.isJSXElement(returnStmt.argument) ? returnStmt.argument : null;
   const conditionalSlotNodeMap = /* @__PURE__ */ new Map();
   const elementPathToUserIdExpr = /* @__PURE__ */ new Map();
   const walk = (node, elementPath = []) => {
-    if (t8.isJSXFragment(node)) {
+    if (t9.isJSXFragment(node)) {
       getDirectChildElements(node.children).forEach((child) => {
         walk(child.node, [...elementPath, child.selectorSegment]);
       });
       return;
     }
-    const tagName = t8.isJSXIdentifier(node.openingElement.name) ? node.openingElement.name.name : "div";
+    const tagName = t9.isJSXIdentifier(node.openingElement.name) ? node.openingElement.name.name : "div";
     const isComponentTag2 = /^[A-Z]/.test(tagName);
     if (!isComponentTag2) {
       const idAttr = node.openingElement.attributes.find(
-        (a) => t8.isJSXAttribute(a) && t8.isJSXIdentifier(a.name) && a.name.name === "id"
+        (a) => t9.isJSXAttribute(a) && t9.isJSXIdentifier(a.name) && a.name.name === "id"
       );
       if (idAttr) {
         const pathKey = elementPath.join(" > ");
-        if (t8.isStringLiteral(idAttr.value)) {
-          elementPathToUserIdExpr.set(pathKey, t8.stringLiteral(idAttr.value.value));
-        } else if (t8.isJSXExpressionContainer(idAttr.value) && idAttr.value.expression && !t8.isJSXEmptyExpression(idAttr.value.expression)) {
-          elementPathToUserIdExpr.set(pathKey, t8.cloneNode(idAttr.value.expression, true));
+        if (t9.isStringLiteral(idAttr.value)) {
+          elementPathToUserIdExpr.set(pathKey, t9.stringLiteral(idAttr.value.value));
+        } else if (t9.isJSXExpressionContainer(idAttr.value) && idAttr.value.expression && !t9.isJSXEmptyExpression(idAttr.value.expression)) {
+          elementPathToUserIdExpr.set(pathKey, t9.cloneNode(idAttr.value.expression, true));
         }
       }
       analyzeAttributes(
@@ -2941,8 +3183,8 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
       conditionalSlotNodeMap
     );
   };
-  if (t8.isJSXElement(returnStmt.argument)) walk(returnStmt.argument);
-  else if (t8.isJSXFragment(returnStmt.argument)) walk(returnStmt.argument);
+  if (t9.isJSXElement(returnStmt.argument)) walk(returnStmt.argument);
+  else if (t9.isJSXFragment(returnStmt.argument)) walk(returnStmt.argument);
   collectAllStateAccesses(templateMethod, stateRefs, stateProps, templateSetupContext, returnStmt.argument);
   assignBindingIds(bindings, propBindings, unresolvedMaps, arrayMaps);
   const elementPathToBindingId = /* @__PURE__ */ new Map();
@@ -2973,44 +3215,44 @@ function analyzeTemplate(templateMethod, stateRefs, classBody2) {
   for (const b of bindings) {
     const pathKey = b.elementPath.join(" > ");
     const userExpr = elementPathToUserIdExpr.get(pathKey);
-    if (userExpr) b.userIdExpr = t8.cloneNode(userExpr, true);
+    if (userExpr) b.userIdExpr = t9.cloneNode(userExpr, true);
   }
   for (const pb of propBindings) {
     if (!pb.elementPath?.length) continue;
     const pathKey = pb.elementPath.join(" > ");
     const userExpr = elementPathToUserIdExpr.get(pathKey);
-    if (userExpr) pb.userIdExpr = t8.cloneNode(userExpr, true);
+    if (userExpr) pb.userIdExpr = t9.cloneNode(userExpr, true);
   }
   for (const um of unresolvedMaps) {
     if (um.containerElementPath?.length) {
       const pathKey = um.containerElementPath.join(" > ");
       const userExpr = elementPathToUserIdExpr.get(pathKey);
-      if (userExpr) um.containerUserIdExpr = t8.cloneNode(userExpr, true);
+      if (userExpr) um.containerUserIdExpr = t9.cloneNode(userExpr, true);
     }
   }
   for (const am of arrayMaps) {
     if (am.containerElementPath?.length) {
       const pathKey = am.containerElementPath.join(" > ");
       const userExpr = elementPathToUserIdExpr.get(pathKey);
-      if (userExpr) am.containerUserIdExpr = t8.cloneNode(userExpr, true);
+      if (userExpr) am.containerUserIdExpr = t9.cloneNode(userExpr, true);
     }
   }
   for (const um of unresolvedMaps) {
     if (!um.computationExpr) continue;
-    if (t8.isIdentifier(um.computationExpr)) {
+    if (t9.isIdentifier(um.computationExpr)) {
       const varName = um.computationExpr.name;
-      um.mapObjectExpr = t8.identifier(varName);
+      um.mapObjectExpr = t9.identifier(varName);
       for (const stmt of templateMethod.body.body) {
-        if (!t8.isVariableDeclaration(stmt)) continue;
+        if (!t9.isVariableDeclaration(stmt)) continue;
         for (const decl of stmt.declarations) {
-          if (t8.isIdentifier(decl.id) && decl.id.name === varName && decl.init) {
-            um.computationExpr = t8.cloneNode(decl.init, true);
+          if (t9.isIdentifier(decl.id) && decl.id.name === varName && decl.init) {
+            um.computationExpr = t9.cloneNode(decl.init, true);
             break;
           }
         }
       }
     } else {
-      um.mapObjectExpr = t8.cloneNode(um.computationExpr, true);
+      um.mapObjectExpr = t9.cloneNode(um.computationExpr, true);
     }
     const derived = buildDerivedUnresolvedMapDescriptor(um.computationExpr, stateRefs, classBody2);
     if (derived) {
@@ -3077,9 +3319,9 @@ function computeConditionalSlotScopedStoreKeys(conditionalSlots, stateProps, sta
     for (const dep of condDeps) conditionKeys.add(dep.observeKey);
     if (!slot.originalExpr) continue;
     const branches = [];
-    if (t8.isConditionalExpression(slot.originalExpr)) {
+    if (t9.isConditionalExpression(slot.originalExpr)) {
       branches.push(slot.originalExpr.consequent, slot.originalExpr.alternate);
-    } else if (t8.isLogicalExpression(slot.originalExpr)) {
+    } else if (t9.isLogicalExpression(slot.originalExpr)) {
       branches.push(slot.originalExpr.right);
     }
     for (const branch of branches) {
@@ -3097,29 +3339,29 @@ function computeConditionalSlotScopedStoreKeys(conditionalSlots, stateProps, sta
   return result;
 }
 function resolveHelperCallExpression(expr, classBody2) {
-  if (!expr || !t8.isCallExpression(expr) || !t8.isMemberExpression(expr.callee) || !t8.isThisExpression(expr.callee.object) || !t8.isIdentifier(expr.callee.property)) {
+  if (!expr || !t9.isCallExpression(expr) || !t9.isMemberExpression(expr.callee) || !t9.isThisExpression(expr.callee.object) || !t9.isIdentifier(expr.callee.property)) {
     return expr;
   }
   const helperName = expr.callee.property.name;
   if (!classBody2) return expr;
   const helperMethod = classBody2.body.find(
-    (node) => t8.isClassMethod(node) && t8.isIdentifier(node.key) && node.key.name === helperName
+    (node) => t9.isClassMethod(node) && t9.isIdentifier(node.key) && node.key.name === helperName
   );
-  if (!helperMethod || !t8.isBlockStatement(helperMethod.body)) return expr;
-  const returnStmt = helperMethod.body.body.find((stmt) => t8.isReturnStatement(stmt) && !!stmt.argument);
-  return returnStmt?.argument ? t8.cloneNode(returnStmt.argument, true) : expr;
+  if (!helperMethod || !t9.isBlockStatement(helperMethod.body)) return expr;
+  const returnStmt = helperMethod.body.body.find((stmt) => t9.isReturnStatement(stmt) && !!stmt.argument);
+  return returnStmt?.argument ? t9.cloneNode(returnStmt.argument, true) : expr;
 }
 function collectHelperMethodDependencies(expr, classBody2, stateRefs) {
-  if (!expr || !t8.isCallExpression(expr) || !t8.isMemberExpression(expr.callee) || !t8.isThisExpression(expr.callee.object) || !t8.isIdentifier(expr.callee.property) || !classBody2) {
+  if (!expr || !t9.isCallExpression(expr) || !t9.isMemberExpression(expr.callee) || !t9.isThisExpression(expr.callee.object) || !t9.isIdentifier(expr.callee.property) || !classBody2) {
     return [];
   }
   const helperMethodName = expr.callee.property.name;
   const helperMethod = classBody2.body.find(
-    (node) => t8.isClassMethod(node) && t8.isIdentifier(node.key) && node.key.name === helperMethodName
+    (node) => t9.isClassMethod(node) && t9.isIdentifier(node.key) && node.key.name === helperMethodName
   );
-  if (!helperMethod || !t8.isBlockStatement(helperMethod.body)) return [];
+  if (!helperMethod || !t9.isBlockStatement(helperMethod.body)) return [];
   const deps = /* @__PURE__ */ new Map();
-  const program12 = t8.program(helperMethod.body.body.map((stmt) => t8.cloneNode(stmt, true)));
+  const program12 = t9.program(helperMethod.body.body.map((stmt) => t9.cloneNode(stmt, true)));
   traverse5(program12, {
     noScope: true,
     MemberExpression(path) {
@@ -3150,26 +3392,26 @@ function buildDerivedUnresolvedMapDescriptor(expr, stateRefs, classBody2) {
   const normalized = resolveHelperCallExpression(expr, classBody2);
   const stages = [];
   const walk = (node) => {
-    if (t8.isCallExpression(node) && t8.isMemberExpression(node.callee) && t8.isIdentifier(node.callee.property) && !node.callee.computed) {
+    if (t9.isCallExpression(node) && t9.isMemberExpression(node.callee) && t9.isIdentifier(node.callee.property) && !node.callee.computed) {
       const method = node.callee.property.name;
       if (method === "filter" || method === "slice" || method === "sort" || method === "reverse") {
         const source2 = walk(node.callee.object);
         if (!source2) return null;
         const stage = { method };
-        if (method === "filter" && t8.isArrowFunctionExpression(node.arguments[0])) {
+        if (method === "filter" && t9.isArrowFunctionExpression(node.arguments[0])) {
           const filterFn = node.arguments[0];
-          stage.itemVariable = t8.isIdentifier(filterFn.params[0]) ? filterFn.params[0].name : "item";
-          stage.indexVariable = t8.isIdentifier(filterFn.params[1]) ? filterFn.params[1].name : void 0;
+          stage.itemVariable = t9.isIdentifier(filterFn.params[0]) ? filterFn.params[0].name : "item";
+          stage.indexVariable = t9.isIdentifier(filterFn.params[1]) ? filterFn.params[1].name : void 0;
           const callbackBodyStatements = extractCallbackBodyStatements(filterFn);
           if (callbackBodyStatements.length > 0) stage.callbackBodyStatements = callbackBodyStatements;
-          if (t8.isExpression(filterFn.body)) {
-            stage.predicateExpr = t8.cloneNode(filterFn.body, true);
-          } else if (t8.isBlockStatement(filterFn.body)) {
+          if (t9.isExpression(filterFn.body)) {
+            stage.predicateExpr = t9.cloneNode(filterFn.body, true);
+          } else if (t9.isBlockStatement(filterFn.body)) {
             const returnStmt = filterFn.body.body.find(
-              (stmt) => t8.isReturnStatement(stmt) && !!stmt.argument
+              (stmt) => t9.isReturnStatement(stmt) && !!stmt.argument
             );
             if (returnStmt?.argument) {
-              stage.predicateExpr = t8.cloneNode(returnStmt.argument, true);
+              stage.predicateExpr = t9.cloneNode(returnStmt.argument, true);
             }
           }
         }
@@ -3177,8 +3419,8 @@ function buildDerivedUnresolvedMapDescriptor(expr, stateRefs, classBody2) {
         return source2;
       }
     }
-    if (!t8.isExpression(node)) return null;
-    if (!t8.isMemberExpression(node) && !t8.isIdentifier(node) && !t8.isThisExpression(node) && !t8.isCallExpression(node)) {
+    if (!t9.isExpression(node)) return null;
+    if (!t9.isMemberExpression(node) && !t9.isIdentifier(node) && !t9.isThisExpression(node) && !t9.isCallExpression(node)) {
       return null;
     }
     const resolved = resolvePath(node, stateRefs);
@@ -3197,41 +3439,41 @@ function buildDerivedUnresolvedMapDescriptor(expr, stateRefs, classBody2) {
   };
 }
 function getHelperMethodObserveKey(expr) {
-  if (!expr || !t8.isCallExpression(expr) || !t8.isMemberExpression(expr.callee) || !t8.isThisExpression(expr.callee.object) || !t8.isIdentifier(expr.callee.property)) {
+  if (!expr || !t9.isCallExpression(expr) || !t9.isMemberExpression(expr.callee) || !t9.isThisExpression(expr.callee.object) || !t9.isIdentifier(expr.callee.property)) {
     return void 0;
   }
   return buildObserveKey([expr.callee.property.name]);
 }
 function analyzeAttributes(node, tagName, elementPath, bindings, propBindings, stateProps, stateRefs, propsParamName, destructuredPropNames, templateSetupContext, classBody2) {
   node.openingElement.attributes.forEach((attr) => {
-    if (!t8.isJSXAttribute(attr) || !t8.isJSXIdentifier(attr.name)) return;
-    if (!attr.value || !t8.isJSXExpressionContainer(attr.value)) return;
+    if (!t9.isJSXAttribute(attr) || !t9.isJSXIdentifier(attr.name)) return;
+    if (!attr.value || !t9.isJSXExpressionContainer(attr.value)) return;
     const name = attr.name.name;
-    if ([
-      "click",
-      "dblclick",
-      "change",
-      "input",
-      "keydown",
-      "keyup",
-      "blur",
-      "focus",
-      "mousedown",
-      "mouseup",
-      "submit",
-      "tap",
-      "longTap",
-      "swipeRight",
-      "swipeUp",
-      "swipeLeft",
-      "swipeDown",
-      "dragstart",
-      "dragend",
-      "dragover",
-      "dragleave",
-      "drop"
-    ].includes(name))
+    if (name === "ref") return;
+    if (EVENT_NAMES.has(name) || EVENT_NAMES.has(toGeaEventType(name))) return;
+    if (name === "dangerouslySetInnerHTML") {
+      const expr2 = attr.value.expression;
+      if (templateSetupContext && !t9.isJSXEmptyExpression(expr2)) {
+        const setupStatements = collectTemplateSetupStatements(expr2, templateSetupContext);
+        const dependencies = collectExpressionDependencies(expr2, stateRefs, setupStatements);
+        const stateDeps = dependencies.filter(
+          (d) => d.storeVar || d.pathParts.length > 0 && d.pathParts[0] !== "props"
+        );
+        if (stateDeps.length > 0) {
+          const selector = generateSelector(elementPath);
+          propBindings.push({
+            propName: "__state__",
+            selector,
+            type: "attribute",
+            attributeName: "dangerouslySetInnerHTML",
+            elementPath: [...elementPath],
+            expression: t9.cloneNode(expr2, true),
+            setupStatements: setupStatements.length > 0 ? setupStatements : void 0
+          });
+        }
+      }
       return;
+    }
     const expr = attr.value.expression;
     const propName = resolvePropRef(expr, propsParamName, destructuredPropNames);
     if (propName) {
@@ -3266,8 +3508,8 @@ function analyzeAttributes(node, tagName, elementPath, bindings, propBindings, s
       propBindings.push(...derived);
     }
     const tagNameNode = node.openingElement.name;
-    const isNativeElement = t8.isJSXIdentifier(tagNameNode) && /^[a-z]/.test(tagNameNode.name);
-    if (isNativeElement && templateSetupContext && !t8.isJSXEmptyExpression(expr)) {
+    const isNativeElement = t9.isJSXIdentifier(tagNameNode) && /^[a-z]/.test(tagNameNode.name);
+    if (isNativeElement && templateSetupContext && !t9.isJSXEmptyExpression(expr)) {
       const setupStatements = collectTemplateSetupStatements(expr, templateSetupContext);
       const dependencies = collectExpressionDependencies(expr, stateRefs, setupStatements);
       const stateDeps = dependencies.filter((d) => d.storeVar || d.pathParts.length > 0 && d.pathParts[0] !== "props");
@@ -3279,8 +3521,8 @@ function analyzeAttributes(node, tagName, elementPath, bindings, propBindings, s
           type: attrType,
           attributeName: attrType === "class" ? void 0 : name,
           elementPath: [...elementPath],
-          expression: t8.cloneNode(expr, true),
-          setupStatements: setupStatements.map((s) => t8.cloneNode(s, true)),
+          expression: t9.cloneNode(expr, true),
+          setupStatements: setupStatements.map((s) => t9.cloneNode(s, true)),
           stateOnly: true
         });
         return;
@@ -3306,13 +3548,13 @@ function collectTextChildren(node, stateRefs, stateProps) {
   const textChildren = [];
   let hasExpr = false;
   node.children.forEach((child) => {
-    if (t8.isJSXText(child)) {
+    if (t9.isJSXText(child)) {
       textChildren.push({ type: "text", value: child.value });
-    } else if (t8.isJSXExpressionContainer(child) && !t8.isJSXEmptyExpression(child.expression)) {
+    } else if (t9.isJSXExpressionContainer(child) && !t9.isJSXEmptyExpression(child.expression)) {
       const expr = child.expression;
-      const isMap = t8.isCallExpression(expr) && t8.isMemberExpression(expr.callee) && t8.isIdentifier(expr.callee.property) && expr.callee.property.name === "map";
+      const isMap = t9.isCallExpression(expr) && t9.isMemberExpression(expr.callee) && t9.isIdentifier(expr.callee.property) && expr.callee.property.name === "map";
       if (!isMap) {
-        if (t8.isTemplateLiteral(expr)) {
+        if (t9.isTemplateLiteral(expr)) {
           for (let i = 0; i < expr.quasis.length; i++) {
             const quasi = expr.quasis[i];
             if (quasi.value.raw) {
@@ -3320,7 +3562,7 @@ function collectTextChildren(node, stateRefs, stateProps) {
             }
             if (i < expr.expressions.length) {
               const innerExpr = expr.expressions[i];
-              if (t8.isExpression(innerExpr)) {
+              if (t9.isExpression(innerExpr)) {
                 textChildren.push({ type: "expression", expression: innerExpr });
                 hasExpr = true;
               }
@@ -3365,26 +3607,26 @@ function collectTextChildren(node, stateRefs, stateProps) {
   return { textTemplate, textExpressions, shouldBuildTextTemplate };
 }
 function parentHasElementChildren(node) {
-  return node.children.some((c) => t8.isJSXElement(c));
+  return node.children.some((c) => t9.isJSXElement(c));
 }
 function getDOMTextNodeIndex(children, childIndex) {
   let domIndex = 0;
   let inTextRun = false;
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
-    if (t8.isJSXText(child)) {
+    if (t9.isJSXText(child)) {
       if (child.value.trim() === "") continue;
       if (!inTextRun) {
         inTextRun = true;
         domIndex++;
       }
-    } else if (t8.isJSXExpressionContainer(child)) {
+    } else if (t9.isJSXExpressionContainer(child)) {
       if (!inTextRun) {
         inTextRun = true;
         domIndex++;
       }
       if (i === childIndex) return domIndex - 1;
-    } else if (t8.isJSXElement(child) || t8.isJSXFragment(child)) {
+    } else if (t9.isJSXElement(child) || t9.isJSXFragment(child)) {
       inTextRun = false;
       domIndex++;
     }
@@ -3396,7 +3638,7 @@ function analyzeChildren(node, tagName, elementPath, bindings, propBindings, arr
     walk(child.node, [...elementPath, child.selectorSegment]);
   });
   node.children.forEach((child, index) => {
-    if (t8.isJSXExpressionContainer(child) && !t8.isJSXEmptyExpression(child.expression)) {
+    if (t9.isJSXExpressionContainer(child) && !t9.isJSXEmptyExpression(child.expression)) {
       const expr = child.expression;
       if (isMapCall(expr)) {
         handleArrayMap(
@@ -3475,12 +3717,12 @@ function analyzeChildren(node, tagName, elementPath, bindings, propBindings, arr
   });
 }
 function isMapCall(expr) {
-  return t8.isCallExpression(expr) && t8.isMemberExpression(expr.callee) && t8.isIdentifier(expr.callee.property) && expr.callee.property.name === "map";
+  return t9.isCallExpression(expr) && t9.isMemberExpression(expr.callee) && t9.isIdentifier(expr.callee.property) && expr.callee.property.name === "map";
 }
 function collectNestedMapCalls(expr) {
-  if (t8.isJSXEmptyExpression(expr)) return [];
+  if (t9.isJSXEmptyExpression(expr)) return [];
   const maps = [];
-  const program12 = t8.program([t8.expressionStatement(t8.cloneNode(expr, true))]);
+  const program12 = t9.program([t9.expressionStatement(t9.cloneNode(expr, true))]);
   traverse5(program12, {
     noScope: true,
     CallExpression(path) {
@@ -3522,19 +3764,19 @@ function collectNestedMapCalls(expr) {
   return maps;
 }
 function collectImportedStoreGetterDependencies(expr, setupStatements, stateRefs) {
-  if (!t8.isIdentifier(expr)) return [];
+  if (!t9.isIdentifier(expr)) return [];
   const deps = /* @__PURE__ */ new Map();
   for (const stmt of setupStatements) {
-    if (!t8.isVariableDeclaration(stmt)) continue;
+    if (!t9.isVariableDeclaration(stmt)) continue;
     for (const decl of stmt.declarations) {
-      if (!t8.isObjectPattern(decl.id) || !t8.isIdentifier(decl.init)) continue;
+      if (!t9.isObjectPattern(decl.id) || !t9.isIdentifier(decl.init)) continue;
       const storeRef = stateRefs.get(decl.init.name);
       if (!storeRef || storeRef.kind !== "imported") continue;
       for (const prop of decl.id.properties) {
-        if (!t8.isObjectProperty(prop)) continue;
-        const localName = t8.isIdentifier(prop.value) ? prop.value.name : t8.isIdentifier(prop.key) ? prop.key.name : null;
+        if (!t9.isObjectProperty(prop)) continue;
+        const localName = t9.isIdentifier(prop.value) ? prop.value.name : t9.isIdentifier(prop.key) ? prop.key.name : null;
         if (localName !== expr.name) continue;
-        const getterName = t8.isIdentifier(prop.key) ? prop.key.name : null;
+        const getterName = t9.isIdentifier(prop.key) ? prop.key.name : null;
         const getterStatePaths = getterName ? storeRef.getterDeps?.get(getterName) : void 0;
         if (getterStatePaths && getterStatePaths.length > 0) {
           for (const pathParts of getterStatePaths) {
@@ -3553,7 +3795,7 @@ function collectImportedStoreGetterDependencies(expr, setupStatements, stateRefs
 function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stateProps, stateRefs, onUnresolvedMap, classBody2, templateSetupContext) {
   const arrayExpr = expr.callee.object;
   const normalizedArrayExpr = resolveHelperCallExpression(arrayExpr, classBody2) || arrayExpr;
-  if (t8.isArrowFunctionExpression(expr.arguments?.[0])) {
+  if (t9.isArrowFunctionExpression(expr.arguments?.[0])) {
     const tpl = extractItemTemplate(expr.arguments[0]);
     if (tpl && !hasExplicitItemKey(tpl)) {
       const loc = tpl.loc?.start;
@@ -3566,18 +3808,18 @@ function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stat
     }
   }
   const result = resolvePath(normalizedArrayExpr, stateRefs);
-  const isDestructuredNonReactive = result?.parts?.length === 1 && result.isImportedState && t8.isIdentifier(normalizedArrayExpr) && (() => {
+  const isDestructuredNonReactive = result?.parts?.length === 1 && result.isImportedState && t9.isIdentifier(normalizedArrayExpr) && (() => {
     const ref = stateRefs.get(normalizedArrayExpr.name);
     if (!ref || ref.kind !== "imported-destructured" || !ref.storeVar || !ref.propName) return false;
     const storeRef = stateRefs.get(ref.storeVar);
     return !storeRef?.reactiveFields?.has(ref.propName);
   })();
-  if (!result?.parts?.length || isDestructuredNonReactive || !t8.isArrowFunctionExpression(expr.arguments[0])) {
-    if (t8.isArrowFunctionExpression(expr.arguments?.[0])) {
+  if (!result?.parts?.length || isDestructuredNonReactive || !t9.isArrowFunctionExpression(expr.arguments[0])) {
+    if (t9.isArrowFunctionExpression(expr.arguments?.[0])) {
       const arrowFn2 = expr.arguments[0];
       normalizeDestructuredMapCallback(arrowFn2);
-      const itemVar2 = t8.isIdentifier(arrowFn2.params[0]) ? arrowFn2.params[0].name : "item";
-      const indexVar2 = t8.isIdentifier(arrowFn2.params[1]) ? arrowFn2.params[1].name : void 0;
+      const itemVar2 = t9.isIdentifier(arrowFn2.params[0]) ? arrowFn2.params[0].name : "item";
+      const indexVar2 = t9.isIdentifier(arrowFn2.params[1]) ? arrowFn2.params[1].name : void 0;
       const itemTemplate2 = extractItemTemplate(arrowFn2);
       const itemIdProp = detectItemIdProperty(itemTemplate2, itemVar2);
       const computationSetupStatements = templateSetupContext ? collectTemplateSetupStatements(normalizedArrayExpr, templateSetupContext) : [];
@@ -3602,8 +3844,8 @@ function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stat
         ...indexVar2 ? { indexVariable: indexVar2 } : {},
         itemIdProperty: itemIdProp,
         rootHasUserId: hasRootUserIdAttribute(itemTemplate2),
-        computationExpr: t8.cloneNode(normalizedArrayExpr, true),
-        computationSetupStatements: computationSetupStatements.map((stmt) => t8.cloneNode(stmt, true)),
+        computationExpr: t9.cloneNode(normalizedArrayExpr, true),
+        computationSetupStatements: computationSetupStatements.map((stmt) => t9.cloneNode(stmt, true)),
         dependencies,
         containerElementPath: [...elementPath],
         ...cbBodyStmts2.length > 0 ? { callbackBodyStatements: cbBodyStmts2 } : {},
@@ -3618,8 +3860,8 @@ function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stat
   const finalPath = result.parts;
   const arrowFn = expr.arguments[0];
   normalizeDestructuredMapCallback(arrowFn);
-  const itemVar = t8.isIdentifier(arrowFn.params[0]) ? arrowFn.params[0].name : "item";
-  const indexVar = t8.isIdentifier(arrowFn.params[1]) ? arrowFn.params[1].name : void 0;
+  const itemVar = t9.isIdentifier(arrowFn.params[0]) ? arrowFn.params[0].name : "item";
+  const indexVar = t9.isIdentifier(arrowFn.params[1]) ? arrowFn.params[1].name : void 0;
   const itemTemplate = extractItemTemplate(arrowFn);
   const cbBodyStmts = extractCallbackBodyStatements(arrowFn);
   const itemIdProperty = detectItemIdProperty(itemTemplate, itemVar);
@@ -3632,15 +3874,15 @@ function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stat
   const storeVar = result.isImportedState ? result.storeVar : void 0;
   const walkBody = (body) => {
     let target = body;
-    if (t8.isBlockStatement(body)) {
-      const returnStmt = body.body.find((s) => t8.isReturnStatement(s));
+    if (t9.isBlockStatement(body)) {
+      const returnStmt = body.body.find((s) => t9.isReturnStatement(s));
       target = returnStmt?.argument;
     }
     if (!target) return;
-    if (t8.isConditionalExpression(target))
-      target = t8.isJSXElement(target.consequent) ? target.consequent : target.alternate;
-    if (t8.isParenthesizedExpression(target)) target = target.expression;
-    if (t8.isJSXElement(target))
+    if (t9.isConditionalExpression(target))
+      target = t9.isJSXElement(target.consequent) ? target.consequent : target.alternate;
+    if (t9.isParenthesizedExpression(target)) target = target.expression;
+    if (t9.isJSXElement(target))
       analyzeJSXInMap(
         target,
         finalPath,
@@ -3655,9 +3897,9 @@ function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stat
         [],
         storeVar
       );
-    else if (t8.isJSXFragment(target))
+    else if (t9.isJSXFragment(target))
       target.children.forEach((fc) => {
-        if (t8.isJSXElement(fc))
+        if (t9.isJSXElement(fc))
           analyzeJSXInMap(
             fc,
             finalPath,
@@ -3673,7 +3915,7 @@ function handleArrayMap(expr, tagName, node, elementPath, index, arrayMaps, stat
             storeVar
           );
       });
-    else if (t8.isParenthesizedExpression(target) && t8.isJSXElement(target.expression))
+    else if (t9.isParenthesizedExpression(target) && t9.isJSXElement(target.expression))
       analyzeJSXInMap(
         target.expression,
         finalPath,
@@ -3740,8 +3982,8 @@ function handleTextBinding(expr, node, tagName, elementPath, bindings, propBindi
             selector: selector3,
             type: "text",
             elementPath: [...elementPath],
-            expression: t8.cloneNode(derivedTemplateExpr, true),
-            setupStatements: setupStatements.map((statement) => t8.cloneNode(statement, true)),
+            expression: t9.cloneNode(derivedTemplateExpr, true),
+            setupStatements: setupStatements.map((statement) => t9.cloneNode(statement, true)),
             ...textNodeIndex !== void 0 ? { textNodeIndex } : {}
           }))
         );
@@ -3777,8 +4019,8 @@ function handleTextBinding(expr, node, tagName, elementPath, bindings, propBindi
             selector: selector2,
             type: "text",
             elementPath: [...elementPath],
-            expression: t8.cloneNode(derivedTemplateExpr, true),
-            setupStatements: setupStatements.map((statement) => t8.cloneNode(statement, true)),
+            expression: t9.cloneNode(derivedTemplateExpr, true),
+            setupStatements: setupStatements.map((statement) => t9.cloneNode(statement, true)),
             ...textNodeIndex !== void 0 ? { textNodeIndex } : {}
           }))
         );
@@ -3804,7 +4046,7 @@ function handleTextBinding(expr, node, tagName, elementPath, bindings, propBindi
     }
   }
   if (templateSetupContext && expressionMayProduceJSX(expr) && rerenderPropNames) {
-    if (t8.isJSXEmptyExpression(expr)) return;
+    if (t9.isJSXEmptyExpression(expr)) return;
     const conditionExpr = extractConditionalControlExpression(expr);
     if (conditionExpr) {
       const condSetupStatements = collectTemplateSetupStatements(conditionExpr, templateSetupContext);
@@ -3829,23 +4071,23 @@ function handleTextBinding(expr, node, tagName, elementPath, bindings, propBindi
       dependentProps.forEach((propName2) => rerenderPropNames.add(propName2));
       if (dependentProps.length > 0 || dependencies.length > 0) {
         rerenderConditions?.push({
-          expression: t8.cloneNode(conditionExpr, true),
-          setupStatements: condSetupStatements.map((s) => t8.cloneNode(s, true))
+          expression: t9.cloneNode(conditionExpr, true),
+          setupStatements: condSetupStatements.map((s) => t9.cloneNode(s, true))
         });
         if (conditionalSlots) {
           const slotId = `c${conditionalSlots.length}`;
           conditionalSlots.push({
             slotId,
-            conditionExpr: t8.cloneNode(conditionExpr, true),
-            setupStatements: condSetupStatements.map((s) => t8.cloneNode(s, true)),
-            htmlSetupStatements: fullSetupStatements.map((s) => t8.cloneNode(s, true)),
+            conditionExpr: t9.cloneNode(conditionExpr, true),
+            setupStatements: condSetupStatements.map((s) => t9.cloneNode(s, true)),
+            htmlSetupStatements: fullSetupStatements.map((s) => t9.cloneNode(s, true)),
             dependentPropNames: [...dependentProps],
             dependencies: dependencies.map((dep) => ({
               observeKey: dep.observeKey,
               pathParts: [...dep.pathParts],
               ...dep.storeVar ? { storeVar: dep.storeVar } : {}
             })),
-            originalExpr: t8.cloneNode(expr, true)
+            originalExpr: t9.cloneNode(expr, true)
           });
           conditionalSlotNodeMap?.set(expr, slotId);
         }
@@ -3854,7 +4096,7 @@ function handleTextBinding(expr, node, tagName, elementPath, bindings, propBindi
   }
   const result = resolveExpr(expr, stateRefs);
   if (!result?.parts?.length) {
-    if (templateSetupContext && !t8.isJSXEmptyExpression(expr) && !expressionMayProduceJSX(expr)) {
+    if (templateSetupContext && !t9.isJSXEmptyExpression(expr) && !expressionMayProduceJSX(expr)) {
       const exprToUse = shouldBuildTextTemplate && textTemplate && !jsxInTextSiblingGroup ? buildTextTemplateExpressionFromParts(textTemplate, textExpressions) : expr;
       const setupStatements = collectTemplateSetupStatements(exprToUse, templateSetupContext);
       const dependencies = collectExpressionDependencies(exprToUse, stateRefs, setupStatements);
@@ -3866,8 +4108,8 @@ function handleTextBinding(expr, node, tagName, elementPath, bindings, propBindi
           selector: selector2,
           type: "text",
           elementPath: [...elementPath],
-          expression: t8.cloneNode(exprToUse, true),
-          setupStatements: setupStatements.map((s) => t8.cloneNode(s, true)),
+          expression: t9.cloneNode(exprToUse, true),
+          setupStatements: setupStatements.map((s) => t9.cloneNode(s, true)),
           stateOnly: true,
           ...textNodeIndex !== void 0 ? { textNodeIndex } : {}
         });
@@ -3913,23 +4155,23 @@ function textSiblingGroupContainsJSX(textExpressions) {
   return textExpressions.some((te) => te.expression && expressionMayProduceJSX(te.expression));
 }
 function expressionMayProduceJSX(expr) {
-  if (t8.isJSXEmptyExpression(expr)) return false;
-  if (t8.isJSXElement(expr) || t8.isJSXFragment(expr)) return true;
-  if (t8.isLogicalExpression(expr)) {
+  if (t9.isJSXEmptyExpression(expr)) return false;
+  if (t9.isJSXElement(expr) || t9.isJSXFragment(expr)) return true;
+  if (t9.isLogicalExpression(expr)) {
     return expressionMayProduceJSX(expr.left) || expressionMayProduceJSX(expr.right);
   }
-  if (t8.isConditionalExpression(expr)) {
+  if (t9.isConditionalExpression(expr)) {
     return expressionMayProduceJSX(expr.consequent) || expressionMayProduceJSX(expr.alternate);
   }
-  if (t8.isParenthesizedExpression(expr)) {
+  if (t9.isParenthesizedExpression(expr)) {
     return expressionMayProduceJSX(expr.expression);
   }
-  if (t8.isCallExpression(expr)) {
+  if (t9.isCallExpression(expr)) {
     const callee = expr.callee;
-    if (t8.isArrowFunctionExpression(callee) || t8.isFunctionExpression(callee)) {
-      if (t8.isBlockStatement(callee.body)) {
+    if (t9.isArrowFunctionExpression(callee) || t9.isFunctionExpression(callee)) {
+      if (t9.isBlockStatement(callee.body)) {
         return callee.body.body.some(
-          (s) => t8.isReturnStatement(s) && !!s.argument && expressionMayProduceJSX(s.argument)
+          (s) => t9.isReturnStatement(s) && !!s.argument && expressionMayProduceJSX(s.argument)
         );
       }
       return expressionMayProduceJSX(callee.body);
@@ -3938,24 +4180,24 @@ function expressionMayProduceJSX(expr) {
   return false;
 }
 function extractConditionalControlExpression(expr) {
-  if (t8.isParenthesizedExpression(expr)) {
+  if (t9.isParenthesizedExpression(expr)) {
     return extractConditionalControlExpression(expr.expression);
   }
-  if (t8.isLogicalExpression(expr) && expr.operator === "&&") {
+  if (t9.isLogicalExpression(expr) && expr.operator === "&&") {
     if (expressionMayProduceJSX(expr.right)) return expr.left;
     if (expressionMayProduceJSX(expr.left)) return expr.right;
     return null;
   }
-  if (t8.isLogicalExpression(expr) && expr.operator === "||") {
+  if (t9.isLogicalExpression(expr) && expr.operator === "||") {
     return expr.left;
   }
-  if (t8.isConditionalExpression(expr)) {
+  if (t9.isConditionalExpression(expr)) {
     return expr.test;
   }
   return null;
 }
 function buildDerivedPropBindings(expr, type, attributeName, elementPath, propsParamName, destructuredPropNames, templateSetupContext, classBody2) {
-  if (t8.isJSXEmptyExpression(expr) || !templateSetupContext) return [];
+  if (t9.isJSXEmptyExpression(expr) || !templateSetupContext) return [];
   const setupStatements = collectTemplateSetupStatements(expr, templateSetupContext);
   const dependentProps = collectDependentPropNames(
     expr,
@@ -3972,15 +4214,15 @@ function buildDerivedPropBindings(expr, type, attributeName, elementPath, propsP
     type,
     attributeName,
     elementPath: [...elementPath],
-    expression: t8.cloneNode(expr, true),
-    setupStatements: setupStatements.map((statement) => t8.cloneNode(statement, true))
+    expression: t9.cloneNode(expr, true),
+    setupStatements: setupStatements.map((statement) => t9.cloneNode(statement, true))
   }));
 }
 function collectDependentPropNames(expr, setupStatements, propsParamName, destructuredPropNames, classBody2) {
   const names = /* @__PURE__ */ new Set();
-  const program12 = t8.program([
-    ...setupStatements.map((statement) => t8.cloneNode(statement, true)),
-    t8.expressionStatement(t8.cloneNode(expr, true))
+  const program12 = t9.program([
+    ...setupStatements.map((statement) => t9.cloneNode(statement, true)),
+    t9.expressionStatement(t9.cloneNode(expr, true))
   ]);
   const getterNamesToExpand = /* @__PURE__ */ new Set();
   traverse5(program12, {
@@ -3992,16 +4234,16 @@ function collectDependentPropNames(expr, setupStatements, propsParamName, destru
     MemberExpression(path) {
       const propName = resolvePropRef(path.node, propsParamName, destructuredPropNames);
       if (propName) names.add(propName);
-      if (classBody2 && t8.isThisExpression(path.node.object) && t8.isIdentifier(path.node.property)) {
+      if (classBody2 && t9.isThisExpression(path.node.object) && t9.isIdentifier(path.node.property)) {
         getterNamesToExpand.add(path.node.property.name);
       }
     }
   });
   if (classBody2 && getterNamesToExpand.size > 0) {
     for (const member of classBody2.body) {
-      if (!t8.isClassMethod(member) || member.kind !== "get" || !t8.isIdentifier(member.key) || !getterNamesToExpand.has(member.key.name))
+      if (!t9.isClassMethod(member) || member.kind !== "get" || !t9.isIdentifier(member.key) || !getterNamesToExpand.has(member.key.name))
         continue;
-      const getterProgram = t8.program(member.body.body.map((s) => t8.cloneNode(s, true)));
+      const getterProgram = t9.program(member.body.body.map((s) => t9.cloneNode(s, true)));
       traverse5(getterProgram, {
         noScope: true,
         Identifier(path) {
@@ -4009,10 +4251,10 @@ function collectDependentPropNames(expr, setupStatements, propsParamName, destru
           if (destructuredPropNames?.has(path.node.name)) names.add(path.node.name);
         },
         MemberExpression(path) {
-          if (t8.isThisExpression(path.node.object) && t8.isIdentifier(path.node.property)) {
-            if (path.node.property.name === "props" && t8.isMemberExpression(path.parentPath?.node)) {
+          if (t9.isThisExpression(path.node.object) && t9.isIdentifier(path.node.property)) {
+            if (path.node.property.name === "props" && t9.isMemberExpression(path.parentPath?.node)) {
               const parent = path.parentPath.node;
-              if (t8.isIdentifier(parent.property)) names.add(parent.property.name);
+              if (t9.isIdentifier(parent.property)) names.add(parent.property.name);
             }
           }
           const propName = resolvePropRef(path.node, propsParamName, destructuredPropNames);
@@ -4023,24 +4265,34 @@ function collectDependentPropNames(expr, setupStatements, propsParamName, destru
   }
   return Array.from(names);
 }
+function isInsideRefAttribute(path) {
+  let current = path;
+  while (current) {
+    if (t9.isJSXAttribute(current.node) && t9.isJSXIdentifier(current.node.name) && current.node.name.name === "ref")
+      return true;
+    current = current.parentPath;
+  }
+  return false;
+}
 function collectAllStateAccesses(templateMethod, stateRefs, stateProps, templateSetupContext, rootExpr) {
-  const params = templateMethod.params.filter((param) => !t8.isTSParameterProperty(param));
-  const expr = rootExpr && !t8.isJSXEmptyExpression(rootExpr) ? t8.cloneNode(rootExpr, true) : t8.arrowFunctionExpression(params, templateMethod.body);
+  const params = templateMethod.params.filter((param) => !t9.isTSParameterProperty(param));
+  const expr = rootExpr && !t9.isJSXEmptyExpression(rootExpr) ? t9.cloneNode(rootExpr, true) : t9.arrowFunctionExpression(params, templateMethod.body);
   const setupStatements = rootExpr && templateSetupContext ? (() => {
     const collected = collectTemplateSetupStatements(rootExpr, templateSetupContext);
-    if (collected.length > 0) return collected.map((s) => t8.cloneNode(s, true));
+    if (collected.length > 0) return collected.map((s) => t9.cloneNode(s, true));
     if (templateSetupContext.earlyReturnBarrierIndex === void 0) return [];
-    return templateSetupContext.statements.slice(0, templateSetupContext.earlyReturnBarrierIndex + 1).map((s) => t8.cloneNode(s, true));
+    return templateSetupContext.statements.slice(0, templateSetupContext.earlyReturnBarrierIndex + 1).map((s) => t9.cloneNode(s, true));
   })() : [];
-  const prog = t8.program([...setupStatements, t8.expressionStatement(expr)]);
+  const prog = t9.program([...setupStatements, t9.expressionStatement(expr)]);
   traverse5(prog, {
     noScope: true,
     Identifier(path) {
       if (!stateRefs.has(path.node.name)) return;
+      if (isInsideRefAttribute(path)) return;
       const ref = stateRefs.get(path.node.name);
-      if (path.parentPath && t8.isMemberExpression(path.parentPath.node) && path.parentPath.node.object === path.node && t8.isIdentifier(path.parentPath.node.property) && !path.parentPath.node.computed) {
+      if (path.parentPath && t9.isMemberExpression(path.parentPath.node) && path.parentPath.node.object === path.node && t9.isIdentifier(path.parentPath.node.property) && !path.parentPath.node.computed) {
         const grandParent = path.parentPath.parentPath;
-        if (!(grandParent && t8.isCallExpression(grandParent.node) && grandParent.node.callee === path.parentPath.node)) {
+        if (!(grandParent && t9.isCallExpression(grandParent.node) && grandParent.node.callee === path.parentPath.node)) {
           return;
         }
       }
@@ -4064,17 +4316,18 @@ function collectAllStateAccesses(templateMethod, stateRefs, stateProps, template
       }
     },
     MemberExpression(path) {
-      if (!t8.isIdentifier(path.node.property)) return;
+      if (!t9.isIdentifier(path.node.property)) return;
+      if (isInsideRefAttribute(path)) return;
       const parent = path.parentPath;
-      if (parent && t8.isCallExpression(parent.node) && parent.node.callee === path.node) return;
+      if (parent && t9.isCallExpression(parent.node) && parent.node.callee === path.node) return;
       const resolved = resolvePath(path.node, stateRefs);
       if (!resolved || resolved.parts === null) return;
       if (resolved.parts.length === 0 && resolved.storeVar) {
         const decl = parent?.node;
-        if (t8.isVariableDeclarator(decl) && t8.isObjectPattern(decl.id)) {
+        if (t9.isVariableDeclarator(decl) && t9.isObjectPattern(decl.id)) {
           for (const prop of decl.id.properties) {
-            if (!t8.isObjectProperty(prop)) continue;
-            const key = t8.isIdentifier(prop.key) ? prop.key.name : t8.isStringLiteral(prop.key) ? prop.key.value : null;
+            if (!t9.isObjectProperty(prop)) continue;
+            const key = t9.isIdentifier(prop.key) ? prop.key.name : t9.isStringLiteral(prop.key) ? prop.key.value : null;
             if (!key) continue;
             const observeKey2 = buildObserveKey([key], resolved.storeVar);
             if (!stateProps.has(observeKey2)) stateProps.set(observeKey2, [key]);
@@ -4092,15 +4345,15 @@ function collectAllStateAccesses(templateMethod, stateRefs, stateProps, template
 }
 function collectItemTemplateStoreDependencies(itemTemplate, itemVar, stateRefs, dependencies) {
   if (!itemTemplate) return;
-  const prog = t8.program([t8.expressionStatement(t8.cloneNode(itemTemplate, true))]);
+  const prog = t9.program([t9.expressionStatement(t9.cloneNode(itemTemplate, true))]);
   traverse5(prog, {
     noScope: true,
     MemberExpression(path) {
       let root = path.node;
-      while (t8.isMemberExpression(root)) root = root.object;
-      if (t8.isIdentifier(root) && root.name === itemVar) return;
+      while (t9.isMemberExpression(root)) root = root.object;
+      if (t9.isIdentifier(root) && root.name === itemVar) return;
       const parent = path.parentPath;
-      if (parent && t8.isCallExpression(parent.node) && parent.node.callee === path.node) return;
+      if (parent && t9.isCallExpression(parent.node) && parent.node.callee === path.node) return;
       const resolved = resolvePath(path.node, stateRefs);
       if (!resolved?.parts?.length) return;
       const parts = [...resolved.parts];
@@ -4117,39 +4370,39 @@ function collectItemTemplateStoreDependencies(itemTemplate, itemVar, stateRefs,
   });
 }
 function detectUnresolvedRelationalClassBindings(itemTemplate, itemVar, stateRefs, dependencies) {
-  if (!itemTemplate || !t8.isJSXElement(itemTemplate)) return [];
+  if (!itemTemplate || !t9.isJSXElement(itemTemplate)) return [];
   const classAttr = itemTemplate.openingElement.attributes.find(
-    (attr) => t8.isJSXAttribute(attr) && t8.isJSXIdentifier(attr.name) && (attr.name.name === "class" || attr.name.name === "className")
+    (attr) => t9.isJSXAttribute(attr) && t9.isJSXIdentifier(attr.name) && (attr.name.name === "class" || attr.name.name === "className")
   );
-  if (!classAttr?.value || !t8.isJSXExpressionContainer(classAttr.value)) return [];
+  if (!classAttr?.value || !t9.isJSXExpressionContainer(classAttr.value)) return [];
   const expr = classAttr.value.expression;
   const conditionals = [];
-  if (t8.isTemplateLiteral(expr)) {
+  if (t9.isTemplateLiteral(expr)) {
     for (const inner of expr.expressions) {
-      if (t8.isConditionalExpression(inner)) conditionals.push(inner);
+      if (t9.isConditionalExpression(inner)) conditionals.push(inner);
     }
-  } else if (t8.isConditionalExpression(expr)) {
+  } else if (t9.isConditionalExpression(expr)) {
     conditionals.push(expr);
   }
   const results = [];
   for (const cond of conditionals) {
-    if (!t8.isBinaryExpression(cond.test)) continue;
+    if (!t9.isBinaryExpression(cond.test)) continue;
     if (!["===", "==", "!==", "!="].includes(cond.test.operator)) continue;
     const matchWhenEqual = cond.test.operator === "===" || cond.test.operator === "==";
     let storeObserveKey;
     let itemSideFound = false;
     let itemProperty;
     for (const side of [cond.test.left, cond.test.right]) {
-      if (t8.isIdentifier(side) && side.name === itemVar) {
+      if (t9.isIdentifier(side) && side.name === itemVar) {
         itemSideFound = true;
         continue;
       }
-      if (t8.isMemberExpression(side) && t8.isIdentifier(side.object) && side.object.name === itemVar && t8.isIdentifier(side.property)) {
+      if (t9.isMemberExpression(side) && t9.isIdentifier(side.object) && side.object.name === itemVar && t9.isIdentifier(side.property)) {
         itemSideFound = true;
         itemProperty = side.property.name;
         continue;
       }
-      if (t8.isMemberExpression(side) || t8.isIdentifier(side)) {
+      if (t9.isMemberExpression(side) || t9.isIdentifier(side)) {
         const resolved = resolvePath(side, stateRefs);
         if (resolved?.parts?.length && resolved.isImportedState) {
           storeObserveKey = buildObserveKey(resolved.parts, resolved.storeVar);
@@ -4159,7 +4412,7 @@ function detectUnresolvedRelationalClassBindings(itemTemplate, itemVar, stateRef
     if (!storeObserveKey || !itemSideFound) continue;
     if (!dependencies.some((d) => d.observeKey === storeObserveKey)) continue;
     const extractName = (node) => {
-      if (t8.isStringLiteral(node)) return node.value.trim() || null;
+      if (t9.isStringLiteral(node)) return node.value.trim() || null;
       return null;
     };
     const className = extractName(cond.consequent) || extractName(cond.alternate);
@@ -4177,218 +4430,6 @@ function detectUnresolvedRelationalClassBindings(itemTemplate, itemVar, stateRef
 
 // src/transform-jsx.ts
 import * as t10 from "@babel/types";
-
-// src/component-event-helpers.ts
-import * as t9 from "@babel/types";
-import { existsSync, readFileSync } from "fs";
-import { dirname, resolve } from "path";
-function toGeaEventType(attrName) {
-  if (attrName.startsWith("on") && attrName.length > 2) {
-    const rest = attrName.slice(2);
-    return rest.charAt(0).toLowerCase() + rest.slice(1);
-  }
-  return attrName;
-}
-function getPropContext(params) {
-  const context = {
-    destructuredPropNames: /* @__PURE__ */ new Set()
-  };
-  const firstParam = params?.[0];
-  if (!firstParam || t9.isRestElement(firstParam)) return context;
-  const binding = getTemplateParamBinding(firstParam);
-  if (!binding) return context;
-  if (t9.isIdentifier(binding)) {
-    context.propsParamName = binding.name;
-    return context;
-  }
-  context.propsParamName = "props";
-  binding.properties.forEach((prop) => {
-    if (t9.isObjectProperty(prop) && t9.isIdentifier(prop.key)) {
-      context.destructuredPropNames.add(prop.key.name);
-    }
-  });
-  return context;
-}
-function getRootClassSelector(node) {
-  for (const attr of node.openingElement.attributes) {
-    if (!t9.isJSXAttribute(attr) || !t9.isJSXIdentifier(attr.name)) continue;
-    if (attr.name.name !== "class" && attr.name.name !== "className") continue;
-    let firstClass = "";
-    if (t9.isStringLiteral(attr.value)) {
-      firstClass = attr.value.value.trim().split(/\s+/)[0] || "";
-    } else if (t9.isJSXExpressionContainer(attr.value) && !t9.isJSXEmptyExpression(attr.value.expression)) {
-      const expr = attr.value.expression;
-      if (t9.isStringLiteral(expr)) {
-        firstClass = expr.value.trim().split(/\s+/)[0] || "";
-      } else if (t9.isTemplateLiteral(expr)) {
-        firstClass = expr.quasis[0]?.value.raw.trim().split(/\s+/)[0] || "";
-      }
-    }
-    if (firstClass) return `.${firstClass}`;
-  }
-  return null;
-}
-function resolvePropCallbackName(expr, context) {
-  if (t9.isIdentifier(expr) && context.destructuredPropNames.has(expr.name)) {
-    return expr.name;
-  }
-  if (t9.isMemberExpression(expr) && t9.isIdentifier(expr.property) && t9.isIdentifier(expr.object) && expr.object.name === (context.propsParamName || "props")) {
-    return expr.property.name;
-  }
-  if (t9.isMemberExpression(expr) && t9.isIdentifier(expr.property) && t9.isMemberExpression(expr.object) && t9.isIdentifier(expr.object.property) && expr.object.property.name === "props" && (t9.isThisExpression(expr.object.object) || t9.isIdentifier(expr.object.object) && expr.object.object.name === (context.propsParamName || "props"))) {
-    return expr.property.name;
-  }
-  return null;
-}
-function extractSingleCallExpression(expr) {
-  if (t9.isCallExpression(expr)) return expr;
-  if (t9.isArrowFunctionExpression(expr) || t9.isFunctionExpression(expr)) {
-    if (t9.isCallExpression(expr.body)) return expr.body;
-    if (!t9.isBlockStatement(expr.body) || expr.body.body.length !== 1) return null;
-    const stmt = expr.body.body[0];
-    if (t9.isExpressionStatement(stmt) && t9.isCallExpression(stmt.expression)) return stmt.expression;
-    if (t9.isReturnStatement(stmt) && stmt.argument && t9.isCallExpression(stmt.argument)) return stmt.argument;
-  }
-  return null;
-}
-function getHoistableRootEvent(attrName, expr, elementPath, context, selector) {
-  if (elementPath.length !== 0 || !selector) return null;
-  if (attrName.startsWith("data-") || attrName === "class" || attrName === "className" || attrName === "style" || attrName === "id")
-    return null;
-  const eventType = toGeaEventType(attrName);
-  const directProp = resolvePropCallbackName(expr, context);
-  if (directProp) return { eventType, propName: directProp, selector };
-  const callExpr = extractSingleCallExpression(expr);
-  if (!callExpr) return null;
-  const propName = resolvePropCallbackName(callExpr.callee, context);
-  if (!propName) return null;
-  return { eventType, propName, selector };
-}
-function resolveImportPath(importer, source) {
-  const base = resolve(dirname(importer), source);
-  const candidates = [
-    base,
-    `${base}.js`,
-    `${base}.jsx`,
-    `${base}.ts`,
-    `${base}.tsx`,
-    resolve(base, "index.js"),
-    resolve(base, "index.jsx"),
-    resolve(base, "index.ts"),
-    resolve(base, "index.tsx")
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-function getReturnedRootJSX(ast, componentClassName) {
-  let found = null;
-  for (const stmt of ast.program.body) {
-    if (t9.isExportDefaultDeclaration(stmt)) {
-      const decl = stmt.declaration;
-      if (t9.isFunctionDeclaration(decl) && decl.body) {
-        const ret = decl.body.body.find(
-          (node) => t9.isReturnStatement(node) && node.argument && t9.isJSXElement(node.argument)
-        );
-        if (ret && t9.isReturnStatement(ret) && ret.argument && t9.isJSXElement(ret.argument)) {
-          return { jsx: ret.argument, context: getPropContext(decl.params) };
-        }
-      }
-      if (t9.isIdentifier(decl)) {
-        for (const bodyStmt of ast.program.body) {
-          if (!t9.isVariableDeclaration(bodyStmt)) continue;
-          for (const dec of bodyStmt.declarations) {
-            if (!t9.isIdentifier(dec.id, { name: decl.name })) continue;
-            if (!dec.init || !t9.isArrowFunctionExpression(dec.init) && !t9.isFunctionExpression(dec.init)) continue;
-            const fn = dec.init;
-            if (t9.isJSXElement(fn.body)) return { jsx: fn.body, context: getPropContext(fn.params) };
-            if (t9.isBlockStatement(fn.body)) {
-              const ret = fn.body.body.find(
-                (node) => t9.isReturnStatement(node) && node.argument && t9.isJSXElement(node.argument)
-              );
-              if (ret && t9.isReturnStatement(ret) && ret.argument && t9.isJSXElement(ret.argument)) {
-                return { jsx: ret.argument, context: getPropContext(fn.params) };
-              }
-            }
-          }
-        }
-      }
-    }
-    if (componentClassName && t9.isExportDefaultDeclaration(stmt) && t9.isClassDeclaration(stmt.declaration) && t9.isIdentifier(stmt.declaration.id, { name: componentClassName })) {
-      const templateMethod = stmt.declaration.body.body.find(
-        (member) => t9.isClassMethod(member) && t9.isIdentifier(member.key) && member.key.name === "template"
-      );
-      if (!templateMethod || !t9.isBlockStatement(templateMethod.body)) return null;
-      const ret = templateMethod.body.body.find(
-        (node) => t9.isReturnStatement(node) && node.argument && t9.isJSXElement(node.argument)
-      );
-      if (ret && t9.isReturnStatement(ret) && ret.argument && t9.isJSXElement(ret.argument)) {
-        return {
-          jsx: ret.argument,
-          context: getPropContext(templateMethod.params)
-        };
-      }
-    }
-  }
-  for (const stmt of ast.program.body) {
-    if (!componentClassName || !t9.isClassDeclaration(stmt) || !t9.isIdentifier(stmt.id, { name: componentClassName }))
-      continue;
-    const templateMethod = stmt.body.body.find(
-      (member) => t9.isClassMethod(member) && t9.isIdentifier(member.key) && member.key.name === "template"
-    );
-    if (!templateMethod || !t9.isBlockStatement(templateMethod.body)) continue;
-    const ret = templateMethod.body.body.find(
-      (node) => t9.isReturnStatement(node) && node.argument && t9.isJSXElement(node.argument)
-    );
-    if (ret && t9.isReturnStatement(ret) && ret.argument && t9.isJSXElement(ret.argument)) {
-      found = {
-        jsx: ret.argument,
-        context: getPropContext(templateMethod.params)
-      };
-      break;
-    }
-  }
-  return found;
-}
-var hoistableRootEventCache = /* @__PURE__ */ new Map();
-function getHoistableRootEventsForImport(importer, source) {
-  const resolved = resolveImportPath(importer, source);
-  if (!resolved) return [];
-  const cached = hoistableRootEventCache.get(resolved);
-  if (cached) return cached;
-  let result;
-  try {
-    const code = readFileSync(resolved, "utf8");
-    const parsed = parseSource(code);
-    if (!parsed) return [];
-    const root = getReturnedRootJSX(parsed.ast, parsed.componentClassName);
-    if (!root) return [];
-    const selector = getRootClassSelector(root.jsx);
-    if (!selector) return [];
-    result = root.jsx.openingElement.attributes.flatMap((attr) => {
-      if (!t9.isJSXAttribute(attr) || !t9.isJSXIdentifier(attr.name)) return [];
-      if (!attr.value || !t9.isJSXExpressionContainer(attr.value) || t9.isJSXEmptyExpression(attr.value.expression)) {
-        return [];
-      }
-      const meta = getHoistableRootEvent(
-        attr.name.name,
-        attr.value.expression,
-        [],
-        root.context,
-        selector
-      );
-      return meta ? [meta] : [];
-    });
-  } catch (err) {
-    console.warn(`[gea] Failed to analyze root events for ${resolved}:`, err instanceof Error ? err.message : err);
-    result = [];
-  }
-  hoistableRootEventCache.set(resolved, result);
-  return result;
-}
-
-// src/transform-jsx.ts
 var RESERVED_HTML_TAG_NAMES = /* @__PURE__ */ new Set([
   "a",
   "abbr",
@@ -4640,10 +4681,43 @@ function extractChildInstanceRef(expr) {
   const instanceVar = memberExpr.property.name;
   return { instanceVar, guardExpr: expr.left };
 }
+function expressionContainsJSX(expr) {
+  let found = false;
+  const check = (node) => {
+    if (found) return;
+    if (t10.isJSXElement(node) || t10.isJSXFragment(node)) {
+      found = true;
+      return;
+    }
+    for (const key of t10.VISITOR_KEYS[node.type] || []) {
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const c of child) {
+          if (c && typeof c === "object" && "type" in c) check(c);
+          if (found) return;
+        }
+      } else if (child && typeof child === "object" && "type" in child) {
+        check(child);
+      }
+      if (found) return;
+    }
+  };
+  check(expr);
+  return found;
+}
+function isChildrenPropAccess(expr) {
+  if (t10.isMemberExpression(expr) && t10.isIdentifier(expr.property) && expr.property.name === "children" && t10.isIdentifier(expr.object) && expr.object.name === "props")
+    return true;
+  if (t10.isMemberExpression(expr) && t10.isIdentifier(expr.property) && expr.property.name === "children" && t10.isMemberExpression(expr.object) && t10.isThisExpression(expr.object.object) && t10.isIdentifier(expr.object.property) && expr.object.property.name === "props")
+    return true;
+  return false;
+}
 function expressionMayBeFalsy(expr) {
   if (t10.isLogicalExpression(expr) && expr.operator === "&&") return true;
   if (t10.isConditionalExpression(expr)) return true;
   if (t10.isBooleanLiteral(expr) && !expr.value) return true;
+  if (t10.isOptionalMemberExpression(expr)) return true;
+  if (t10.isOptionalCallExpression(expr)) return true;
   return false;
 }
 function canBeBoolean(expr) {
@@ -4679,6 +4753,14 @@ function buildAttrSkipCondition(expr, rawExpr) {
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "data", "cite", "poster", "background"]);
+function wrapWithSanitizeAttr(attrName, expr) {
+  if (!URL_ATTRS.has(attrName)) return expr;
+  return t10.callExpression(t10.identifier("__sanitizeAttr"), [
+    t10.stringLiteral(attrName),
+    t10.callExpression(t10.identifier("String"), [expr])
+  ]);
+}
 function getStaticStringValue(expr) {
   if (t10.isStringLiteral(expr)) return expr.value;
   if (t10.isTemplateLiteral(expr) && expr.expressions.length === 0) {
@@ -5130,6 +5212,7 @@ function processElement(node, parts, ctx, elementPath = []) {
   }
   let generatedEventSuffix;
   let generatedEventToken;
+  let dangerouslySetInnerHTMLExpr;
   node.openingElement.attributes.forEach((attr) => {
     if (t10.isJSXSpreadAttribute(attr)) {
       const err = new Error(
@@ -5142,6 +5225,13 @@ function processElement(node, parts, ctx, elementPath = []) {
     const attrName = attr.name.name;
     if (attrName === "key") return;
     if (attrName === "id" && hasBindingId) return;
+    if (attrName === "dangerouslySetInnerHTML") {
+      const dsiValue = attr.value;
+      if (t10.isJSXExpressionContainer(dsiValue) && !t10.isJSXEmptyExpression(dsiValue.expression)) {
+        dangerouslySetInnerHTMLExpr = dsiValue.expression;
+      }
+      return;
+    }
     if (attrName === "ref") {
       const attrValue2 = attr.value;
       if (t10.isJSXExpressionContainer(attrValue2) && !t10.isJSXEmptyExpression(attrValue2.expression) && ctx.refBindings && ctx.refCounter) {
@@ -5338,7 +5428,8 @@ function processElement(node, parts, ctx, elementPath = []) {
         parts.push({ type: "string", value: html });
         const expr = transformJSXExpression(rawExpr, ctx);
         const skipCondition = buildAttrSkipCondition(expr, rawExpr);
-        const templateExpr = propAttrName === "class" ? buildTrimmedClassValueExpression(expr) : expr;
+        const sanitizedExpr = wrapWithSanitizeAttr(propAttrName, expr);
+        const templateExpr = propAttrName === "class" ? buildTrimmedClassValueExpression(expr) : sanitizedExpr;
         if (t10.isBooleanLiteral(skipCondition) && !skipCondition.value) {
           parts.push({ type: "string", value: ` ${propAttrName}="` });
           parts.push({ type: "expression", value: templateExpr });
@@ -5367,7 +5458,12 @@ function processElement(node, parts, ctx, elementPath = []) {
       html += ` ${propAttrName}`;
     }
   });
-  if (node.openingElement.selfClosing) {
+  if (dangerouslySetInnerHTMLExpr) {
+    html += ">";
+    parts.push({ type: "string", value: html });
+    parts.push({ type: "expression", value: dangerouslySetInnerHTMLExpr });
+    appendString(parts, `</${effectiveTag}>`);
+  } else if (node.openingElement.selfClosing) {
     if (isComp) {
       parts.push({ type: "string", value: html + `></${effectiveTag}>` });
     } else if (VOID_ELEMENTS.has(effectiveTag)) {
@@ -5472,7 +5568,11 @@ function processChildren(children, parts, ctx, elementPath, dcCursor, directChil
         if (expressionMayBeFalsy(rawExpr)) {
           expr = t10.logicalExpression("||", expr, t10.stringLiteral(""));
         }
-        parts.push({ type: "expression", value: expr });
+        const skipEscape = childCallInfo || isChildrenPropAccess(rawExpr) || expressionContainsJSX(rawExpr) || ctx.inMapCallback;
+        const safeExpr = skipEscape ? expr : t10.callExpression(t10.identifier("__escapeHtml"), [
+          t10.callExpression(t10.identifier("String"), [expr])
+        ]);
+        parts.push({ type: "expression", value: safeExpr });
       }
     }
   });
@@ -5539,7 +5639,7 @@ import { appendToBody, id as id3, js as js2, jsMethod } from "eszter";
 import { createRequire as createRequire6 } from "module";
 var require7 = createRequire6(import.meta.url);
 var traverse6 = require7("@babel/traverse").default;
-var EVENT_NAMES = /* @__PURE__ */ new Set([
+var EVENT_NAMES2 = /* @__PURE__ */ new Set([
   "click",
   "dblclick",
   "mousedown",
@@ -5623,7 +5723,7 @@ function buildDummyFromTree(tree, keyPathParts) {
         t11.objectProperty(t11.identifier(key), buildDummyFromTree(value === true ? {} : value, keyPathParts.slice(1)))
       );
     } else if (value === true) {
-      props.push(t11.objectProperty(t11.identifier(key), t11.stringLiteral("")));
+      props.push(t11.objectProperty(t11.identifier(key), t11.stringLiteral(" ")));
     } else {
       props.push(t11.objectProperty(t11.identifier(key), buildDummyFromTree(value, null)));
     }
@@ -5712,21 +5812,36 @@ function generatePatchItemMethod(arrayMap, templatePropNames, wholeParamName, te
   for (const entry of patchedEntries) {
     const navExpr = entry.childPath.length > 0 ? refMap.get(entry.childPath.join("_")) || buildElementNavExpr(elVar, entry.childPath) : elVar;
     switch (entry.type) {
-      case "className":
+      case "className": {
+        const classVal = t11.identifier("__cn");
         body.push(
-          t11.expressionStatement(
-            t11.assignmentExpression(
-              "=",
-              t11.memberExpression(navExpr, t11.identifier("className")),
+          t11.variableDeclaration("var", [
+            t11.variableDeclarator(
+              classVal,
               buildTrimmedClassValueExpression(t11.cloneNode(entry.expression, true))
             )
+          ]),
+          t11.ifStatement(
+            t11.binaryExpression("!==", t11.memberExpression(navExpr, t11.identifier("className")), classVal),
+            t11.expressionStatement(
+              t11.assignmentExpression(
+                "=",
+                t11.memberExpression(t11.cloneNode(navExpr, true), t11.identifier("className")),
+                classVal
+              )
+            )
           )
         );
         break;
+      }
       case "text":
         body.push(
           t11.expressionStatement(
-            t11.assignmentExpression("=", t11.memberExpression(navExpr, t11.identifier("textContent")), entry.expression)
+            t11.assignmentExpression(
+              "=",
+              t11.memberExpression(t11.memberExpression(navExpr, t11.identifier("firstChild")), t11.identifier("nodeValue")),
+              entry.expression
+            )
           )
         );
         break;
@@ -5803,12 +5918,27 @@ function generatePatchItemMethod(arrayMap, templatePropNames, wholeParamName, te
                   t11.stringLiteral(entry.attributeName)
                 ])
               ),
-              t11.expressionStatement(
-                t11.callExpression(t11.memberExpression(navExpr, t11.identifier("setAttribute")), [
-                  t11.stringLiteral(entry.attributeName),
-                  t11.callExpression(t11.identifier("String"), [attrVal])
-                ])
-              )
+              t11.blockStatement([
+                t11.variableDeclaration("const", [
+                  t11.variableDeclarator(t11.identifier("__newAttr"), t11.callExpression(t11.identifier("String"), [attrVal]))
+                ]),
+                t11.ifStatement(
+                  t11.binaryExpression(
+                    "!==",
+                    t11.callExpression(
+                      t11.memberExpression(t11.cloneNode(navExpr, true), t11.identifier("getAttribute")),
+                      [t11.stringLiteral(entry.attributeName)]
+                    ),
+                    t11.identifier("__newAttr")
+                  ),
+                  t11.expressionStatement(
+                    t11.callExpression(
+                      t11.memberExpression(t11.cloneNode(navExpr, true), t11.identifier("setAttribute")),
+                      [t11.stringLiteral(entry.attributeName), t11.identifier("__newAttr")]
+                    )
+                  )
+                )
+              ])
             )
           );
         }
@@ -5910,7 +6040,7 @@ function walkJSXForPatch(node, path, entries, rootIsComponent = false) {
   for (const attr of node.openingElement.attributes) {
     if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
     const name = attr.name.name;
-    if (name === "key" || EVENT_NAMES.has(name)) continue;
+    if (name === "key" || EVENT_NAMES2.has(name)) continue;
     if (!t11.isJSXExpressionContainer(attr.value) || t11.isJSXEmptyExpression(attr.value.expression)) continue;
     if (name === "class" || name === "className") {
       entries.push({
@@ -6103,7 +6233,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
       for (const attr of cloned.openingElement.attributes) {
         if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
         const propName = attr.name.name;
-        if (propName === "key" || EVENT_NAMES.has(propName)) continue;
+        if (propName === "key" || EVENT_NAMES2.has(propName)) continue;
         if (!t11.isJSXExpressionContainer(attr.value) || t11.isJSXEmptyExpression(attr.value.expression)) continue;
         const exprClone = t11.cloneNode(attr.value.expression, true);
         const tempProg = t11.file(t11.program([t11.expressionStatement(exprClone)]));
@@ -6393,7 +6523,11 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
       case "text":
         body.push(
           t11.expressionStatement(
-            t11.assignmentExpression("=", t11.memberExpression(navExpr, t11.identifier("textContent")), entry.expression)
+            t11.assignmentExpression(
+              "=",
+              t11.memberExpression(t11.memberExpression(navExpr, t11.identifier("firstChild")), t11.identifier("nodeValue")),
+              entry.expression
+            )
           )
         );
         break;
@@ -6470,12 +6604,27 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
                   t11.stringLiteral(entry.attributeName)
                 ])
               ),
-              t11.expressionStatement(
-                t11.callExpression(t11.memberExpression(navExpr, t11.identifier("setAttribute")), [
-                  t11.stringLiteral(entry.attributeName),
-                  t11.callExpression(t11.identifier("String"), [attrVal])
-                ])
-              )
+              t11.blockStatement([
+                t11.variableDeclaration("const", [
+                  t11.variableDeclarator(t11.identifier("__newAttr"), t11.callExpression(t11.identifier("String"), [attrVal]))
+                ]),
+                t11.ifStatement(
+                  t11.binaryExpression(
+                    "!==",
+                    t11.callExpression(
+                      t11.memberExpression(t11.cloneNode(navExpr, true), t11.identifier("getAttribute")),
+                      [t11.stringLiteral(entry.attributeName)]
+                    ),
+                    t11.identifier("__newAttr")
+                  ),
+                  t11.expressionStatement(
+                    t11.callExpression(
+                      t11.memberExpression(t11.cloneNode(navExpr, true), t11.identifier("setAttribute")),
+                      [t11.stringLiteral(entry.attributeName), t11.identifier("__newAttr")]
+                    )
+                  )
+                )
+              ])
             )
           );
         }
@@ -6531,7 +6680,7 @@ function generateCreateItemMethod(arrayMap, templatePropNames, wholeParamName, t
     for (const attr of cloned.openingElement.attributes) {
       if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
       const name = attr.name.name;
-      if (name === "key" || EVENT_NAMES.has(name)) continue;
+      if (name === "key" || EVENT_NAMES2.has(name)) continue;
       if (!t11.isJSXExpressionContainer(attr.value) || t11.isJSXEmptyExpression(attr.value.expression)) continue;
       const exprClone = t11.cloneNode(attr.value.expression, true);
       const tempProg = t11.file(t11.program([t11.expressionStatement(exprClone)]));
@@ -6609,38 +6758,6 @@ function branchContainsJSX(expr) {
 }
 
 // src/generate-clone.ts
-var EVENT_NAMES2 = /* @__PURE__ */ new Set([
-  "click",
-  "dblclick",
-  "mousedown",
-  "mouseup",
-  "mouseover",
-  "mouseout",
-  "mousemove",
-  "keydown",
-  "keyup",
-  "keypress",
-  "focus",
-  "blur",
-  "input",
-  "change",
-  "submit",
-  "scroll",
-  "touchstart",
-  "touchmove",
-  "touchend",
-  "tap",
-  "longTap",
-  "swipeRight",
-  "swipeUp",
-  "swipeLeft",
-  "swipeDown",
-  "dragstart",
-  "dragend",
-  "dragover",
-  "dragleave",
-  "drop"
-]);
 var EVENT_TYPES2 = /* @__PURE__ */ new Set([
   "click",
   "dblclick",
@@ -6801,7 +6918,8 @@ function collectClonePatchEntries(node, path, entries, rootIsComponent = false)
   for (const attr of node.openingElement.attributes) {
     if (!t12.isJSXAttribute(attr) || !t12.isJSXIdentifier(attr.name)) continue;
     const name = attr.name.name;
-    if (name === "key" || name === "id" || EVENT_NAMES2.has(name)) continue;
+    if (name === "key" || name === "id" || name === "ref" || EVENT_NAMES.has(name) || EVENT_NAMES.has(toGeaEventType(name)))
+      continue;
     if (!t12.isJSXExpressionContainer(attr.value) || t12.isJSXEmptyExpression(attr.value.expression)) continue;
     if (name === "class" || name === "className") {
       entries.push({
@@ -7385,30 +7503,7 @@ function getMapContextKey(ctx) {
 }
 function ensureMapItemHelper(classBody2, ctx, helperName) {
   if (classBody2.body.some((m) => t13.isClassMethod(m) && t13.isIdentifier(m.key) && m.key.name === helperName)) return;
-  const itemsExpr = (() => {
-    const [first] = ctx.arrayPathParts;
-    const unresolvedMatch = first?.match(/^__unresolved_(\d+)$/);
-    if (unresolvedMatch) {
-      const mapIdx = Number(unresolvedMatch[1]);
-      return t13.callExpression(
-        t13.memberExpression(
-          t13.memberExpression(
-            t13.memberExpression(t13.thisExpression(), t13.identifier("__geaMaps")),
-            t13.numericLiteral(mapIdx),
-            true
-          ),
-          t13.identifier("getItems")
-        ),
-        []
-      );
-    }
-    const base = ctx.isImportedState ? t13.identifier(ctx.storeVar || "store") : t13.thisExpression();
-    if (ctx.arrayPathParts.length === 0) return base;
-    const [, ...rest] = ctx.arrayPathParts;
-    const isIndex = /^\d+$/.test(first);
-    const optionalFirst = ctx.isImportedState ? t13.memberExpression(base, isIndex ? t13.numericLiteral(Number(first)) : t13.identifier(first), isIndex) : t13.optionalMemberExpression(base, isIndex ? t13.numericLiteral(Number(first)) : t13.identifier(first), isIndex, true);
-    return rest.length > 0 ? buildMemberChainFromParts(optionalFirst, rest) : optionalFirst;
-  })();
+  const itemsExpr = buildArrayItemsExpr(ctx);
   const findPredicate = ctx.itemIdProperty && ctx.itemIdProperty !== ITEM_IS_KEY ? t13.arrowFunctionExpression(
     [t13.identifier("__candidate")],
     t13.binaryExpression(
@@ -7437,17 +7532,19 @@ function ensureMapItemHelper(classBody2, ctx, helperName) {
       t13.identifier("__itemId")
     )
   );
-  const method = jsMethod2`${id4(helperName)}(e) {
-    var __el = e.target;
-    while (__el && __el.__geaKey == null && (!__el.getAttribute || !__el.getAttribute('data-gea-item-id'))) __el = __el.parentElement;
-    if (!__el) return null;
-    if (__el.__geaItem) return __el.__geaItem;
-    const __itemId = __el.__geaKey ?? (__el.getAttribute && __el.getAttribute('data-gea-item-id'));
-    if (__itemId == null) return null;
-    const __items = ${itemsExpr};
-    const __arr = Array.isArray(__items) ? __items : Array.isArray(__items?.__getTarget) ? __items.__getTarget : [];
-    return __arr.find(${findPredicate}) || __itemId;
-  }`;
+  const method = jsMethod2`${id4(helperName)}(e) {}`;
+  method.body.body.push(
+    ...buildGeaItemDomWalk(),
+    ...jsBlockBody`
+      if (!__el) return null;
+      if (__el.__geaItem) return __el.__geaItem;
+      const __itemId = __el.__geaKey ?? (__el.getAttribute && __el.getAttribute('data-gea-item-id'));
+      if (__itemId == null) return null;
+      const __items = ${itemsExpr};
+      const __arr = Array.isArray(__items) ? __items : Array.isArray(__items?.__getTarget) ? __items.__getTarget : [];
+      return __arr.find(${findPredicate}) || __itemId;
+    `
+  );
   classBody2.body.unshift(method);
 }
 function getLocalFunctionInSetup(name, setupStatements) {
@@ -7730,6 +7827,36 @@ function referencesIdentifier(nodes, name) {
   }
   return nodes.some(walk);
 }
+function buildArrayItemsExpr(ctx, opts = {}) {
+  const [first] = ctx.arrayPathParts;
+  const unresolvedMatch = first?.match(/^__unresolved_(\d+)$/);
+  if (unresolvedMatch) {
+    const mapIdx = Number(unresolvedMatch[1]);
+    return t13.callExpression(
+      t13.memberExpression(
+        t13.memberExpression(
+          t13.memberExpression(t13.thisExpression(), t13.identifier("__geaMaps")),
+          t13.numericLiteral(mapIdx),
+          true
+        ),
+        t13.identifier("getItems")
+      ),
+      []
+    );
+  }
+  const base = ctx.isImportedState ? opts.raw ? t13.memberExpression(t13.identifier(ctx.storeVar || "store"), t13.identifier("__raw")) : t13.identifier(ctx.storeVar || "store") : t13.thisExpression();
+  if (ctx.arrayPathParts.length === 0) return base;
+  const [, ...rest] = ctx.arrayPathParts;
+  const isIndex = /^\d+$/.test(first);
+  const firstAccess = ctx.isImportedState ? t13.memberExpression(base, isIndex ? t13.numericLiteral(Number(first)) : t13.identifier(first), isIndex) : t13.optionalMemberExpression(base, isIndex ? t13.numericLiteral(Number(first)) : t13.identifier(first), isIndex, true);
+  return rest.length > 0 ? buildMemberChainFromParts(firstAccess, rest) : firstAccess;
+}
+function buildGeaItemDomWalk() {
+  return jsBlockBody`
+    var __el = e.target;
+    while (__el && __el.__geaKey == null && (!__el.getAttribute || !__el.getAttribute('data-gea-item-id'))) __el = __el.parentElement;
+  `;
+}
 function buildMapEventBody(handler, paramContext) {
   const ctx = handler.mapContext;
   const itemVar = ctx.itemVariable || "item";
@@ -7738,16 +7865,29 @@ function buildMapEventBody(handler, paramContext) {
     extractHandlerBody(handler.handlerExpression, paramContext.propNames),
     paramContext
   );
+  const needsItem = referencesIdentifier(handlerBody, itemVar);
+  const needsIndex = !!(ctx.indexVariable && referencesIdentifier(handlerBody, ctx.indexVariable));
+  if (needsIndex && !needsItem) {
+    const rawArrayExpr = buildArrayItemsExpr(ctx, { raw: true });
+    const preamble2 = [
+      ...buildGeaItemDomWalk(),
+      ...jsBlockBody`
+        if (!__el || !__el.__geaItem) return;
+        const ${id4(ctx.indexVariable)} = ${rawArrayExpr}.indexOf(__el.__geaItem);
+      `
+    ];
+    return [...preamble2, ...handlerBody];
+  }
   const preamble = jsBlockBody`
     const ${id4(itemVar)} = this.${id4(helperName)}(e);
     if (!${id4(itemVar)}) { return; }
   `;
-  if (ctx.indexVariable && referencesIdentifier(handlerBody, ctx.indexVariable)) {
+  if (needsIndex) {
+    const rawArrayExpr = buildArrayItemsExpr(ctx, { raw: true });
     preamble.push(
+      ...buildGeaItemDomWalk(),
       ...jsBlockBody`
-        var __el = e.target;
-        while (__el && __el.__geaKey == null && (!__el.getAttribute || !__el.getAttribute('data-gea-item-id'))) __el = __el.parentElement;
-        const ${id4(ctx.indexVariable)} = __el ? Array.prototype.indexOf.call(__el.parentNode.children, __el) : -1;
+        const ${id4(ctx.indexVariable)} = __el ? ${rawArrayExpr}.indexOf(__el.__geaItem) : -1;
       `
     );
   }
@@ -7809,7 +7949,7 @@ function getDirectPropMappings(child, templatePropNames) {
   }
   return mappings.length > 0 ? mappings : null;
 }
-function injectChildComponents(ast, componentInstances, directForwardingChildren) {
+function injectChildComponents(ast, componentInstances, directForwardingChildren, className) {
   if (componentInstances.size === 0) return;
   const childComponents = Array.from(componentInstances.values()).flat();
   const constructionOrder = [...childComponents].sort((a, b) => (b.dfsIndex ?? 0) - (a.dfsIndex ?? 0));
@@ -7819,6 +7959,7 @@ function injectChildComponents(ast, componentInstances, directForwardingChildren
   traverse7(ast, {
     ClassDeclaration(path) {
       if (!t14.isIdentifier(path.node.superClass)) return;
+      if (className && (!t14.isIdentifier(path.node.id) || path.node.id.name !== className)) return;
       const existingCtor = path.node.body.body.find(
         (m) => t14.isClassMethod(m) && t14.isIdentifier(m.key) && m.key.name === "constructor"
       );
@@ -7894,10 +8035,14 @@ function injectChildComponents(ast, componentInstances, directForwardingChildren
     }
   });
 }
-function injectComponentRegistrations(ast, componentInstances) {
+function injectComponentRegistrations(ast, componentInstances, className) {
   traverse7(ast, {
     ClassMethod(path) {
       if (!t14.isIdentifier(path.node.key) || path.node.key.name !== "template") return;
+      if (className) {
+        const ownerClass = path.findParent((p) => t14.isClassDeclaration(p.node));
+        if (ownerClass && t14.isIdentifier(ownerClass.node.id) && ownerClass.node.id.name !== className) return;
+      }
       const registrations = Array.from(componentInstances.keys()).map(
         (tagName) => t14.expressionStatement(
           t14.callExpression(t14.memberExpression(t14.identifier("Component"), t14.identifier("_register")), [
@@ -8159,7 +8304,7 @@ function buildSimpleUpdate(binding, param, stateRefs) {
   }
   if (binding.textNodeIndex !== void 0 && binding.type === "text") {
     const idx = t15.numericLiteral(binding.textNodeIndex);
-    return js3`if (${el}) { const __tn = ${jsExpr2`${el}.childNodes[${idx}]`}; if (__tn && __tn.nodeValue !== ${valueExpr}) __tn.nodeValue = ${valueExpr}; }`;
+    return js3`if (${el}) { let __tn = ${jsExpr2`${el}.childNodes[${idx}]`}; if (!__tn || __tn.nodeType !== 3) { __tn = document.createTextNode(${valueExpr}); ${jsExpr2`${el}.insertBefore(__tn, ${el}.childNodes[${idx}] || null)`}; } else if (__tn.nodeValue !== ${valueExpr}) { __tn.nodeValue = ${valueExpr}; } }`;
   }
   if (target === "textContent" && binding.bindingId && binding.bindingId !== "" && !binding.userIdExpr) {
     const suffix = t15.stringLiteral(binding.bindingId);
@@ -8302,6 +8447,7 @@ function mergeObserveHandlers(bindings, stateRefs) {
 import * as t17 from "@babel/types";
 import { appendToBody as appendToBody3, id as id8, js as js4, jsBlockBody as jsBlockBody3, jsExpr as jsExpr3, jsMethod as jsMethod5 } from "eszter";
 import { createRequire as createRequire9 } from "module";
+var URL_ATTRS2 = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "data", "cite", "poster", "background"]);
 var require10 = createRequire9(import.meta.url);
 var traverse9 = require10("@babel/traverse").default;
 function getArrayPathParts(arrayMap) {
@@ -8414,12 +8560,32 @@ function buildPropPatcherFunction(binding, propName) {
           t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
         )
       )
-    ) : t17.expressionStatement(
-      t17.callExpression(t17.memberExpression(target, t17.identifier("setAttribute")), [
-        t17.stringLiteral(attrName),
-        t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
-      ])
-    );
+    ) : t17.blockStatement([
+      t17.variableDeclaration("const", [
+        t17.variableDeclarator(
+          t17.identifier("__newAttr"),
+          URL_ATTRS2.has(attrName) ? t17.callExpression(t17.identifier("__sanitizeAttr"), [
+            t17.stringLiteral(attrName),
+            t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
+          ]) : t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
+        )
+      ]),
+      t17.ifStatement(
+        t17.binaryExpression(
+          "!==",
+          t17.callExpression(t17.memberExpression(t17.cloneNode(target, true), t17.identifier("getAttribute")), [
+            t17.stringLiteral(attrName)
+          ]),
+          t17.identifier("__newAttr")
+        ),
+        t17.expressionStatement(
+          t17.callExpression(t17.memberExpression(t17.cloneNode(target, true), t17.identifier("setAttribute")), [
+            t17.stringLiteral(attrName),
+            t17.identifier("__newAttr")
+          ])
+        )
+      )
+    ]);
     return t17.arrowFunctionExpression(
       [row, value],
       t17.blockStatement([
@@ -8561,12 +8727,29 @@ function buildPatchEntryPropPatcher(entry) {
           t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
         )
       )
-    ) : t17.expressionStatement(
-      t17.callExpression(t17.memberExpression(target, t17.identifier("setAttribute")), [
-        t17.stringLiteral(attrName),
-        t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
-      ])
-    );
+    ) : t17.blockStatement([
+      t17.variableDeclaration("const", [
+        t17.variableDeclarator(
+          t17.identifier("__newAttr"),
+          t17.callExpression(t17.identifier("String"), [t17.identifier("__attrValue")])
+        )
+      ]),
+      t17.ifStatement(
+        t17.binaryExpression(
+          "!==",
+          t17.callExpression(t17.memberExpression(t17.cloneNode(target, true), t17.identifier("getAttribute")), [
+            t17.stringLiteral(attrName)
+          ]),
+          t17.identifier("__newAttr")
+        ),
+        t17.expressionStatement(
+          t17.callExpression(t17.memberExpression(t17.cloneNode(target, true), t17.identifier("setAttribute")), [
+            t17.stringLiteral(attrName),
+            t17.identifier("__newAttr")
+          ])
+        )
+      )
+    ]);
     return t17.arrowFunctionExpression(
       [row, value, item],
       t17.blockStatement([
@@ -9025,7 +9208,10 @@ function buildConditionalPatchStatement(binding, target, itemVariable) {
     if (__attrValue == null || __attrValue === false) {
       ${jsExpr3`${target}.removeAttribute(${binding.attributeName || "class"})`};
     } else {
-      ${jsExpr3`${target}.setAttribute(${binding.attributeName || "class"}, String(__attrValue))`};
+      const __newAttr = String(__attrValue);
+      if (${jsExpr3`${target}.getAttribute(${binding.attributeName || "class"})`} !== __newAttr) {
+        ${jsExpr3`${target}.setAttribute(${binding.attributeName || "class"}, __newAttr)`};
+      }
     }
   `
   );
@@ -9753,6 +9939,7 @@ function generateComponentArrayResult(um, arrayPropName, imports, propNames, _cl
 // src/apply-reactivity.ts
 import { createRequire as createRequire12 } from "module";
 var generate2 = "default" in babelGenerator ? babelGenerator.default : babelGenerator;
+var URL_ATTRS3 = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "data", "cite", "poster", "background"]);
 var require13 = createRequire12(import.meta.url);
 var traverse12 = require13("@babel/traverse").default;
 var BOOLEAN_HTML_ATTRS = /* @__PURE__ */ new Set([
@@ -10198,31 +10385,63 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             const valueExpr = pb.expression && pb.setupStatements ? t20.identifier("__boundValue") : t20.identifier("value");
             let updateStmt;
             if (pb.type === "text" && pb.textNodeIndex !== void 0) {
+              const tnIdx = t20.numericLiteral(pb.textNodeIndex);
               const tnAccess = t20.memberExpression(
                 t20.memberExpression(t20.identifier("__el"), t20.identifier("childNodes")),
-                t20.numericLiteral(pb.textNodeIndex),
+                t20.cloneNode(tnIdx, true),
                 true
               );
-              updateStmt = t20.blockStatement([
-                t20.variableDeclaration("const", [t20.variableDeclarator(t20.identifier("__tn"), tnAccess)]),
-                t20.ifStatement(
-                  t20.logicalExpression(
-                    "&&",
+              const notTextNode = t20.logicalExpression(
+                "||",
+                t20.unaryExpression("!", t20.identifier("__tn")),
+                t20.binaryExpression(
+                  "!==",
+                  t20.memberExpression(t20.identifier("__tn"), t20.identifier("nodeType")),
+                  t20.numericLiteral(3)
+                )
+              );
+              const insertNewTextNode = t20.blockStatement([
+                t20.expressionStatement(
+                  t20.assignmentExpression(
+                    "=",
                     t20.identifier("__tn"),
-                    t20.binaryExpression(
-                      "!==",
-                      t20.memberExpression(t20.identifier("__tn"), t20.identifier("nodeValue")),
-                      valueExpr
-                    )
-                  ),
-                  t20.expressionStatement(
-                    t20.assignmentExpression(
-                      "=",
-                      t20.memberExpression(t20.identifier("__tn"), t20.identifier("nodeValue")),
+                    t20.callExpression(t20.memberExpression(t20.identifier("document"), t20.identifier("createTextNode")), [
                       t20.cloneNode(valueExpr, true)
+                    ])
+                  )
+                ),
+                t20.expressionStatement(
+                  t20.callExpression(t20.memberExpression(t20.identifier("__el"), t20.identifier("insertBefore")), [
+                    t20.identifier("__tn"),
+                    t20.logicalExpression(
+                      "||",
+                      t20.memberExpression(
+                        t20.memberExpression(t20.identifier("__el"), t20.identifier("childNodes")),
+                        t20.cloneNode(tnIdx, true),
+                        true
+                      ),
+                      t20.nullLiteral()
                     )
+                  ])
+                )
+              ]);
+              const updateExisting = t20.ifStatement(
+                t20.binaryExpression(
+                  "!==",
+                  t20.memberExpression(t20.identifier("__tn"), t20.identifier("nodeValue")),
+                  t20.cloneNode(valueExpr, true)
+                ),
+                t20.expressionStatement(
+                  t20.assignmentExpression(
+                    "=",
+                    t20.memberExpression(t20.identifier("__tn"), t20.identifier("nodeValue")),
+                    t20.cloneNode(valueExpr, true)
                   )
                 )
+              );
+              updateStmt = t20.blockStatement([
+                t20.variableDeclaration("let", [t20.variableDeclarator(t20.identifier("__tn"), tnAccess)]),
+                t20.ifStatement(notTextNode, insertNewTextNode, updateExisting)
               ]);
             } else if (pb.type === "text") {
               const targetProp = pb.propName === "children" ? "innerHTML" : "textContent";
@@ -10352,6 +10571,41 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
             } else if (pb.type === "attribute" && pb.attributeName) {
               const attrName = pb.attributeName;
               if (attrName === "style") {
+                const cssTextExpr = t20.conditionalExpression(
+                  t20.binaryExpression("===", t20.unaryExpression("typeof", valueExpr), t20.stringLiteral("object")),
+                  t20.callExpression(
+                    t20.memberExpression(
+                      t20.callExpression(
+                        t20.memberExpression(
+                          t20.callExpression(t20.memberExpression(t20.identifier("Object"), t20.identifier("entries")), [
+                            valueExpr
+                          ]),
+                          t20.identifier("map")
+                        ),
+                        [
+                          t20.arrowFunctionExpression(
+                            [t20.arrayPattern([t20.identifier("k"), t20.identifier("v")])],
+                            t20.binaryExpression(
+                              "+",
+                              t20.binaryExpression(
+                                "+",
+                                t20.callExpression(t20.memberExpression(t20.identifier("k"), t20.identifier("replace")), [
+                                  t20.regExpLiteral("[A-Z]", "g"),
+                                  t20.stringLiteral("-$&")
+                                ]),
+                                t20.stringLiteral(": ")
+                              ),
+                              t20.identifier("v")
+                            )
+                          )
+                        ]
+                      ),
+                      t20.identifier("join")
+                    ),
+                    [t20.stringLiteral("; ")]
+                  ),
+                  t20.callExpression(t20.identifier("String"), [valueExpr])
+                );
                 updateStmt = t20.ifStatement(
                   t20.logicalExpression(
                     "||",
@@ -10363,51 +10617,53 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                       t20.stringLiteral("style")
                     ])
                   ),
-                  t20.expressionStatement(
-                    t20.assignmentExpression(
-                      "=",
-                      t20.memberExpression(
-                        t20.memberExpression(t20.identifier("__el"), t20.identifier("style")),
-                        t20.identifier("cssText")
+                  t20.blockStatement([
+                    t20.variableDeclaration("const", [t20.variableDeclarator(t20.identifier("__newCss"), cssTextExpr)]),
+                    t20.ifStatement(
+                      t20.binaryExpression(
+                        "!==",
+                        t20.memberExpression(
+                          t20.memberExpression(t20.identifier("__el"), t20.identifier("style")),
+                          t20.identifier("cssText")
+                        ),
+                        t20.identifier("__newCss")
                       ),
-                      t20.conditionalExpression(
-                        t20.binaryExpression("===", t20.unaryExpression("typeof", valueExpr), t20.stringLiteral("object")),
-                        t20.callExpression(
+                      t20.expressionStatement(
+                        t20.assignmentExpression(
+                          "=",
                           t20.memberExpression(
-                            t20.callExpression(
-                              t20.memberExpression(
-                                t20.callExpression(t20.memberExpression(t20.identifier("Object"), t20.identifier("entries")), [
-                                  valueExpr
-                                ]),
-                                t20.identifier("map")
-                              ),
-                              [
-                                t20.arrowFunctionExpression(
-                                  [t20.arrayPattern([t20.identifier("k"), t20.identifier("v")])],
-                                  t20.binaryExpression(
-                                    "+",
-                                    t20.binaryExpression(
-                                      "+",
-                                      t20.callExpression(t20.memberExpression(t20.identifier("k"), t20.identifier("replace")), [
-                                        t20.regExpLiteral("[A-Z]", "g"),
-                                        t20.stringLiteral("-$&")
-                                      ]),
-                                      t20.stringLiteral(": ")
-                                    ),
-                                    t20.identifier("v")
-                                  )
-                                )
-                              ]
-                            ),
-                            t20.identifier("join")
+                            t20.memberExpression(t20.identifier("__el"), t20.identifier("style")),
+                            t20.identifier("cssText")
                           ),
-                          [t20.stringLiteral("; ")]
-                        ),
-                        t20.callExpression(t20.identifier("String"), [valueExpr])
+                          t20.identifier("__newCss")
+                        )
                       )
                     )
-                  )
+                  ])
                 );
+              } else if (attrName === "dangerouslySetInnerHTML") {
+                updateStmt = t20.blockStatement([
+                  t20.variableDeclaration("const", [
+                    t20.variableDeclarator(
+                      t20.identifier("__newHtml"),
+                      t20.callExpression(t20.identifier("String"), [valueExpr])
+                    )
+                  ]),
+                  t20.ifStatement(
+                    t20.binaryExpression(
+                      "!==",
+                      t20.memberExpression(t20.identifier("__el"), t20.identifier("innerHTML")),
+                      t20.identifier("__newHtml")
+                    ),
+                    t20.expressionStatement(
+                      t20.assignmentExpression(
+                        "=",
+                        t20.memberExpression(t20.identifier("__el"), t20.identifier("innerHTML")),
+                        t20.identifier("__newHtml")
+                      )
+                    )
+                  )
+                ]);
               } else {
                 const isBooleanAttr = BOOLEAN_HTML_ATTRS.has(attrName);
                 const removeCondition = isBooleanAttr ? t20.unaryExpression("!", valueExpr) : t20.logicalExpression(
@@ -10415,6 +10671,10 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                   t20.binaryExpression("===", valueExpr, t20.nullLiteral()),
                   t20.binaryExpression("===", valueExpr, t20.identifier("undefined"))
                 );
+                const newAttrValueExpr = isBooleanAttr ? t20.stringLiteral("") : URL_ATTRS3.has(attrName) ? t20.callExpression(t20.identifier("__sanitizeAttr"), [
+                  t20.stringLiteral(attrName),
+                  t20.callExpression(t20.identifier("String"), [valueExpr])
+                ]) : t20.callExpression(t20.identifier("String"), [valueExpr]);
                 updateStmt = t20.ifStatement(
                   removeCondition,
                   t20.expressionStatement(
@@ -10422,12 +10682,24 @@ function applyStaticReactivity(ast, originalAST, className, sourceFile, imports,
                       t20.stringLiteral(attrName)
                     ])
                   ),
-                  t20.expressionStatement(
-                    t20.callExpression(t20.memberExpression(t20.identifier("__el"), t20.identifier("setAttribute")), [
-                      t20.stringLiteral(attrName),
-                      isBooleanAttr ? t20.stringLiteral("") : t20.callExpression(t20.identifier("String"), [valueExpr])
-                    ])
-                  )
+                  t20.blockStatement([
+                    t20.variableDeclaration("const", [t20.variableDeclarator(t20.identifier("__newAttr"), newAttrValueExpr)]),
+                    t20.ifStatement(
+                      t20.binaryExpression(
+                        "!==",
+                        t20.callExpression(t20.memberExpression(t20.identifier("__el"), t20.identifier("getAttribute")), [
+                          t20.stringLiteral(attrName)
+                        ]),
+                        t20.identifier("__newAttr")
+                      ),
+                      t20.expressionStatement(
+                        t20.callExpression(t20.memberExpression(t20.identifier("__el"), t20.identifier("setAttribute")), [
+                          t20.stringLiteral(attrName),
+                          t20.identifier("__newAttr")
+                        ])
+                      )
+                    )
+                  ])
                 );
               }
             } else {
@@ -13852,13 +14124,13 @@ function transformComponentFile(ast, imports, storeImports, className, sourceFil
             child.guardSetupStatements = guardSetupStatements;
           }
         }
-        injectChildComponents(ast, componentInstances, directForwardingSet);
+        injectChildComponents(ast, componentInstances, directForwardingSet, className);
         compiledChildren.push(...allChildren);
         transformed = true;
       }
       if (allComponentInstances.size > 0) {
         ensureComponentImport(ast, imports);
-        injectComponentRegistrations(ast, allComponentInstances);
+        injectComponentRegistrations(ast, allComponentInstances, className);
         transformed = true;
       }
       if (transformed) {
@@ -14615,6 +14887,9 @@ ${entries.join(",\n")}
         if (hasJSX) {
           const originalAST = parseSource(code).ast;
           if (componentClassNames.length > 0) {
+            for (const cn of componentClassNames) {
+              if (!imports.has(cn)) imports.set(cn, cleanId);
+            }
             for (const cn of componentClassNames) {
               const result = transformComponentFile(
                 ast,
@@ -14668,6 +14943,8 @@ ${entries.join(",\n")}
           if (hmrAdded) transformed = true;
         }
         if (!transformed) return null;
+        ensureImport(ast, "@geajs/core", "__escapeHtml");
+        ensureImport(ast, "@geajs/core", "__sanitizeAttr");
         const output = generate3(ast, { sourceMaps: true, sourceFileName: cleanId }, code);
         return { code: output.code, map: output.map };
       } catch (error) {