marko 6.0.0-next.3.73 → 6.0.0-next.3.75

package/dist/translator/index.js

@@ -1251,11 +1251,14 @@ function escapeStyle(val) {
 }
 
 // src/html/serializer.ts
+var kTouchedIterator = Symbol();
 var { hasOwnProperty } = {};
 var Generator = function* () {
 }().constructor;
 var AsyncGenerator = async function* () {
 }().constructor;
+patchIteratorNext(Generator.prototype);
+patchIteratorNext(AsyncGenerator.prototype);
 var KNOWN_SYMBOLS = (() => {
   const KNOWN_SYMBOLS2 = /* @__PURE__ */ new Map();
   for (const name2 of Object.getOwnPropertyNames(Symbol)) {
@@ -1501,6 +1504,13 @@ function toAccess(accessor) {
   const start = accessor[0];
   return start === '"' || start >= "0" && start <= "9" ? "[" + accessor + "]" : "." + accessor;
 }
+function patchIteratorNext(proto) {
+  const { next } = proto;
+  proto.next = function(value) {
+    this[kTouchedIterator] = 1;
+    return next.call(this, value);
+  };
+}
 
 // src/html/writer.ts
 var K_SCOPE_ID = Symbol("Scope ID");
@@ -1604,7 +1614,7 @@ function toMemberExpression(object, key, optional) {
 }
 
 // src/translator/util/runtime.ts
-var pureFunctions = [
+var pureDOMFunctions = /* @__PURE__ */ new Set([
   "awaitTag",
   "conditional",
   "conditionalClosure",
@@ -1622,7 +1632,7 @@ var pureFunctions = [
   "loopTo",
   "state",
   "value"
-];
+]);
 function importRuntime(name2) {
   const { output } = getMarkoOpts();
   return toMemberExpression(
@@ -1635,7 +1645,7 @@ function callRuntime(name2, ...args) {
     importRuntime(name2),
     filterArguments(args)
   );
-  if (pureFunctions.includes(name2)) {
+  if (isOutputDOM() && pureDOMFunctions.has(name2)) {
     callExpression2.leadingComments = [
       {
         type: "CommentBlock",
@@ -6493,115 +6503,121 @@ var html_comment_default = {
     }
     tag.skip();
   },
-  translate(tag) {
-    const tagExtra = tag.node.extra;
-    const commentBinding = tagExtra[kCommentTagBinding];
-    const hasVar = !!tag.node.var;
-    if (hasVar) {
-      const getterId = tagExtra[kGetterId2];
-      if (isOutputHTML()) {
-        translateVar(
-          tag,
-          callRuntime(
-            "nodeRef",
-            getterId && getScopeIdIdentifier(getSection(tag)),
-            getterId && import_compiler38.types.stringLiteral(getterId)
-          )
-        );
-      } else {
-        const varName = tag.node.var.name;
-        const references = tag.scope.getBinding(varName).referencePaths;
-        let getterFnIdentifier;
-        if (getterId) {
-          getterFnIdentifier = (0, import_compiler38.getProgram)().scope.generateUidIdentifier(
-            `get_${varName}`
-          );
-          (0, import_compiler38.getProgram)().node.body.push(
-            import_compiler38.types.variableDeclaration("const", [
-              import_compiler38.types.variableDeclarator(
-                getterFnIdentifier,
-                callRuntime(
-                  "nodeRef",
-                  import_compiler38.types.stringLiteral(getterId),
-                  getScopeAccessorLiteral(commentBinding)
-                )
-              )
-            ])
+  translate: {
+    enter(tag) {
+      const tagExtra = tag.node.extra;
+      const commentBinding = tagExtra[kCommentTagBinding];
+      const hasVar = !!tag.node.var;
+      if (hasVar) {
+        const getterId = tagExtra[kGetterId2];
+        if (isOutputHTML()) {
+          translateVar(
+            tag,
+            callRuntime(
+              "nodeRef",
+              getterId && getScopeIdIdentifier(getSection(tag)),
+              getterId && import_compiler38.types.stringLiteral(getterId)
+            )
           );
-        }
-        for (const reference of references) {
-          const referenceSection = getSection(reference);
-          if (isInvokedFunction(reference)) {
-            reference.parentPath.replaceWith(
-              import_compiler38.types.expressionStatement(
-                createScopeReadExpression(referenceSection, commentBinding)
-              )
+        } else {
+          const varName = tag.node.var.name;
+          const references = tag.scope.getBinding(varName).referencePaths;
+          let getterFnIdentifier;
+          if (getterId) {
+            getterFnIdentifier = (0, import_compiler38.getProgram)().scope.generateUidIdentifier(
+              `get_${varName}`
             );
-          } else if (getterFnIdentifier) {
-            reference.replaceWith(
-              import_compiler38.types.callExpression(getterFnIdentifier, [
-                getScopeExpression(referenceSection, getSection(tag))
+            (0, import_compiler38.getProgram)().node.body.push(
+              import_compiler38.types.variableDeclaration("const", [
+                import_compiler38.types.variableDeclarator(
+                  getterFnIdentifier,
+                  callRuntime(
+                    "nodeRef",
+                    import_compiler38.types.stringLiteral(getterId),
+                    getScopeAccessorLiteral(commentBinding)
+                  )
+                )
               ])
             );
           }
+          for (const reference of references) {
+            const referenceSection = getSection(reference);
+            if (isInvokedFunction(reference)) {
+              reference.parentPath.replaceWith(
+                import_compiler38.types.expressionStatement(
+                  createScopeReadExpression(referenceSection, commentBinding)
+                )
+              );
+            } else if (getterFnIdentifier) {
+              reference.replaceWith(
+                import_compiler38.types.callExpression(getterFnIdentifier, [
+                  getScopeExpression(referenceSection, getSection(tag))
+                ])
+              );
+            }
+          }
         }
       }
-    }
-    if (tagExtra[kCommentTagBinding]) {
-      visit(tag, 32 /* Get */);
-    }
-    const write2 = writeTo(tag);
-    enter2(tag);
-    write2`<!--`;
-    if (isOutputHTML()) {
-      for (const child of tag.node.body.body) {
-        if (import_compiler38.types.isMarkoText(child)) {
-          write2`${child.value}`;
-        } else if (import_compiler38.types.isMarkoPlaceholder(child)) {
-          write2`${callRuntime("escapeXML", child.value)}`;
-        }
+      if (tagExtra[kCommentTagBinding]) {
+        visit(tag, 32 /* Get */);
       }
-    } else {
-      const templateQuasis = [];
-      const templateExpressions = [];
-      let currentQuasi = "";
-      for (const child of tag.node.body.body) {
-        if (import_compiler38.types.isMarkoText(child)) {
-          currentQuasi += child.value;
-        } else if (import_compiler38.types.isMarkoPlaceholder(child)) {
-          templateQuasis.push(import_compiler38.types.templateElement({ raw: currentQuasi }));
-          templateExpressions.push(child.value);
-          currentQuasi = "";
+      enter2(tag);
+      writeTo(tag)`<!--`;
+    },
+    exit(tag) {
+      const tagExtra = tag.node.extra;
+      const commentBinding = tagExtra[kCommentTagBinding];
+      const write2 = writeTo(tag);
+      if (isOutputHTML()) {
+        for (const child of tag.node.body.body) {
+          if (import_compiler38.types.isMarkoText(child)) {
+            write2`${child.value}`;
+          } else if (import_compiler38.types.isMarkoPlaceholder(child)) {
+            write2`${callRuntime("escapeXML", child.value)}`;
+          }
         }
-      }
-      if (templateExpressions.length === 0) {
-        write2`${currentQuasi}`;
       } else {
-        templateQuasis.push(import_compiler38.types.templateElement({ raw: currentQuasi }));
-        addStatement(
-          "render",
-          getSection(tag),
-          tagExtra.referencedBindings,
-          import_compiler38.types.expressionStatement(
-            callRuntime(
-              "data",
-              import_compiler38.types.memberExpression(
-                scopeIdentifier,
-                getScopeAccessorLiteral(commentBinding),
-                true
-              ),
-              import_compiler38.types.templateLiteral(templateQuasis, templateExpressions)
+        const templateQuasis = [];
+        const templateExpressions = [];
+        let currentQuasi = "";
+        for (const child of tag.node.body.body) {
+          if (import_compiler38.types.isMarkoText(child)) {
+            currentQuasi += child.value;
+          } else if (import_compiler38.types.isMarkoPlaceholder(child)) {
+            templateQuasis.push(import_compiler38.types.templateElement({ raw: currentQuasi }));
+            templateExpressions.push(child.value);
+            currentQuasi = "";
+          }
+        }
+        if (templateExpressions.length === 0) {
+          write2`${currentQuasi}`;
+        } else {
+          templateQuasis.push(import_compiler38.types.templateElement({ raw: currentQuasi }));
+          addStatement(
+            "render",
+            getSection(tag),
+            tagExtra.referencedBindings,
+            import_compiler38.types.expressionStatement(
+              callRuntime(
+                "data",
+                import_compiler38.types.memberExpression(
+                  scopeIdentifier,
+                  getScopeAccessorLiteral(commentBinding),
+                  true
+                ),
+                import_compiler38.types.templateLiteral(templateQuasis, templateExpressions)
+              )
             )
-          )
-        );
+          );
+        }
       }
+      exit2(tag);
+      write2`-->`;
+      if (commentBinding) {
+        markNode(tag, commentBinding);
+      }
+      tag.remove();
     }
-    exit2(tag);
-    write2`-->`;
-    if (commentBinding) {
-      markNode(tag, commentBinding);
-    }
-    tag.remove();
   },
   parseOptions: {
     text: true
@@ -6703,124 +6719,167 @@ var html_script_default = {
       }
     }
   },
-  translate(tag) {
-    const tagExtra = tag.node.extra;
-    const nodeRef2 = tagExtra[kNativeTagBinding];
-    const isHTML = isOutputHTML();
-    const write2 = writeTo(tag);
-    const section = getSection(tag);
-    const hasVar = !!tag.node.var;
-    if (hasVar) {
-      const getterId = tagExtra[kGetterId3];
-      if (isHTML) {
-        const varName = tag.node.var.name;
-        const references = tag.scope.getBinding(varName).referencePaths;
-        for (const reference of references) {
-          serializeOwners(getSection(reference), section);
-        }
-        translateVar(
-          tag,
-          callRuntime(
-            "nodeRef",
-            getterId && getScopeIdIdentifier(section),
-            getterId && import_compiler39.types.stringLiteral(getterId)
-          )
-        );
-      } else {
-        const varName = tag.node.var.name;
-        const references = tag.scope.getBinding(varName).referencePaths;
-        let getterFnIdentifier;
-        if (getterId) {
-          getterFnIdentifier = (0, import_compiler39.getProgram)().scope.generateUidIdentifier(
-            `get_${varName}`
-          );
-          (0, import_compiler39.getProgram)().node.body.push(
-            import_compiler39.types.variableDeclaration("const", [
-              import_compiler39.types.variableDeclarator(
-                getterFnIdentifier,
-                callRuntime(
-                  "nodeRef",
-                  import_compiler39.types.stringLiteral(getterId),
-                  getScopeAccessorLiteral(nodeRef2)
-                )
-              )
-            ])
+  translate: {
+    enter(tag) {
+      const tagExtra = tag.node.extra;
+      const nodeRef2 = tagExtra[kNativeTagBinding];
+      const isHTML = isOutputHTML();
+      const write2 = writeTo(tag);
+      const section = getSection(tag);
+      const hasVar = !!tag.node.var;
+      if (hasVar) {
+        const getterId = tagExtra[kGetterId3];
+        if (isHTML) {
+          const varName = tag.node.var.name;
+          const references = tag.scope.getBinding(varName).referencePaths;
+          for (const reference of references) {
+            serializeOwners(getSection(reference), section);
+          }
+          translateVar(
+            tag,
+            callRuntime(
+              "nodeRef",
+              getterId && getScopeIdIdentifier(section),
+              getterId && import_compiler39.types.stringLiteral(getterId)
+            )
           );
-        }
-        for (const reference of references) {
-          const referenceSection = getSection(reference);
-          if (isInvokedFunction(reference)) {
-            reference.parentPath.replaceWith(
-              import_compiler39.types.expressionStatement(
-                createScopeReadExpression(referenceSection, nodeRef2)
-              )
+        } else {
+          const varName = tag.node.var.name;
+          const references = tag.scope.getBinding(varName).referencePaths;
+          let getterFnIdentifier;
+          if (getterId) {
+            getterFnIdentifier = (0, import_compiler39.getProgram)().scope.generateUidIdentifier(
+              `get_${varName}`
             );
-          } else if (getterFnIdentifier) {
-            reference.replaceWith(
-              import_compiler39.types.callExpression(getterFnIdentifier, [
-                getScopeExpression(referenceSection, getSection(tag))
+            (0, import_compiler39.getProgram)().node.body.push(
+              import_compiler39.types.variableDeclaration("const", [
+                import_compiler39.types.variableDeclarator(
+                  getterFnIdentifier,
+                  callRuntime(
+                    "nodeRef",
+                    import_compiler39.types.stringLiteral(getterId),
+                    getScopeAccessorLiteral(nodeRef2)
+                  )
+                )
               ])
             );
           }
+          for (const reference of references) {
+            const referenceSection = getSection(reference);
+            if (isInvokedFunction(reference)) {
+              reference.parentPath.replaceWith(
+                import_compiler39.types.expressionStatement(
+                  createScopeReadExpression(referenceSection, nodeRef2)
+                )
+              );
+            } else if (getterFnIdentifier) {
+              reference.replaceWith(
+                import_compiler39.types.callExpression(getterFnIdentifier, [
+                  getScopeExpression(referenceSection, getSection(tag))
+                ])
+              );
+            }
+          }
         }
       }
-    }
-    let visitAccessor;
-    if (nodeRef2) {
-      visitAccessor = getScopeAccessorLiteral(nodeRef2);
-      visit(tag, 32 /* Get */);
-    }
-    write2`<script`;
-    const usedAttrs = getUsedAttrs2(tag.node);
-    const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
-    for (const attr2 of staticAttrs) {
-      const { name: name2, value } = attr2;
-      const { confident, computed } = value.extra || {};
-      const valueReferences = value.extra?.referencedBindings;
-      switch (name2) {
-        case "class":
-        case "style": {
-          const helper = `${name2}Attr`;
-          if (confident) {
-            write2`${getHTMLRuntime()[helper](computed)}`;
-          } else if (isHTML) {
-            write2`${callRuntime(helper, value)}`;
-          } else {
-            addStatement(
-              "render",
-              section,
-              valueReferences,
-              import_compiler39.types.expressionStatement(
-                callRuntime(
-                  helper,
-                  import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  value
+      let visitAccessor;
+      if (nodeRef2) {
+        visitAccessor = getScopeAccessorLiteral(nodeRef2);
+        visit(tag, 32 /* Get */);
+      }
+      write2`<script`;
+      const usedAttrs = getUsedAttrs2(tag.node);
+      const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
+      for (const attr2 of staticAttrs) {
+        const { name: name2, value } = attr2;
+        const { confident, computed } = value.extra || {};
+        const valueReferences = value.extra?.referencedBindings;
+        switch (name2) {
+          case "class":
+          case "style": {
+            const helper = `${name2}Attr`;
+            if (confident) {
+              write2`${getHTMLRuntime()[helper](computed)}`;
+            } else if (isHTML) {
+              write2`${callRuntime(helper, value)}`;
+            } else {
+              addStatement(
+                "render",
+                section,
+                valueReferences,
+                import_compiler39.types.expressionStatement(
+                  callRuntime(
+                    helper,
+                    import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    value
+                  )
                 )
-              )
-            );
+              );
+            }
+            break;
           }
-          break;
-        }
-        default:
-          if (confident) {
-            write2`${getHTMLRuntime().attr(name2, computed)}`;
-          } else if (isHTML) {
-            if (isEventHandler(name2)) {
-              addHTMLEffectCall(section, valueReferences);
+          default:
+            if (confident) {
+              write2`${getHTMLRuntime().attr(name2, computed)}`;
+            } else if (isHTML) {
+              if (isEventHandler(name2)) {
+                addHTMLEffectCall(section, valueReferences);
+              } else {
+                write2`${callRuntime("attr", import_compiler39.types.stringLiteral(name2), value)}`;
+              }
+            } else if (isEventHandler(name2)) {
+              addStatement(
+                "effect",
+                section,
+                valueReferences,
+                import_compiler39.types.expressionStatement(
+                  callRuntime(
+                    "on",
+                    import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler39.types.stringLiteral(getEventHandlerName(name2)),
+                    value
+                  )
+                )
+              );
             } else {
-              write2`${callRuntime("attr", import_compiler39.types.stringLiteral(name2), value)}`;
+              addStatement(
+                "render",
+                section,
+                valueReferences,
+                import_compiler39.types.expressionStatement(
+                  callRuntime(
+                    "attr",
+                    import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler39.types.stringLiteral(name2),
+                    value
+                  )
+                )
+              );
             }
-          } else if (isEventHandler(name2)) {
+            break;
+        }
+      }
+      if (spreadExpression) {
+        if (isHTML) {
+          addHTMLEffectCall(section, tagExtra.referencedBindings);
+          if (skipExpression) {
+            write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler39.types.stringLiteral("script"))}`;
+          } else {
+            write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler39.types.stringLiteral("script"))}`;
+          }
+        } else {
+          if (skipExpression) {
             addStatement(
-              "effect",
+              "render",
               section,
-              valueReferences,
+              tagExtra.referencedBindings,
               import_compiler39.types.expressionStatement(
                 callRuntime(
-                  "on",
-                  import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler39.types.stringLiteral(getEventHandlerName(name2)),
-                  value
+                  "partialAttrs",
+                  scopeIdentifier,
+                  visitAccessor,
+                  spreadExpression,
+                  skipExpression
                 )
               )
             );
@@ -6828,119 +6887,84 @@ var html_script_default = {
             addStatement(
               "render",
               section,
-              valueReferences,
+              tagExtra.referencedBindings,
               import_compiler39.types.expressionStatement(
                 callRuntime(
-                  "attr",
-                  import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler39.types.stringLiteral(name2),
-                  value
+                  "attrs",
+                  scopeIdentifier,
+                  visitAccessor,
+                  spreadExpression
                 )
               )
             );
           }
-          break;
-      }
-    }
-    if (spreadExpression) {
-      if (isHTML) {
-        addHTMLEffectCall(section, tagExtra.referencedBindings);
-        if (skipExpression) {
-          write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler39.types.stringLiteral("script"))}`;
-        } else {
-          write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler39.types.stringLiteral("script"))}`;
-        }
-      } else {
-        if (skipExpression) {
           addStatement(
-            "render",
+            "effect",
             section,
             tagExtra.referencedBindings,
             import_compiler39.types.expressionStatement(
-              callRuntime(
-                "partialAttrs",
-                scopeIdentifier,
-                visitAccessor,
-                spreadExpression,
-                skipExpression
-              )
-            )
+              callRuntime("attrsEvents", scopeIdentifier, visitAccessor)
+            ),
+            false
           );
+        }
+      }
+      write2`>`;
+      enter2(tag);
+    },
+    exit(tag) {
+      const tagExtra = tag.node.extra;
+      const nodeRef2 = tagExtra[kNativeTagBinding];
+      const write2 = writeTo(tag);
+      const visitAccessor = nodeRef2 && getScopeAccessorLiteral(nodeRef2);
+      if (isOutputHTML()) {
+        for (const child of tag.node.body.body) {
+          if (import_compiler39.types.isMarkoText(child)) {
+            write2`${child.value}`;
+          } else if (import_compiler39.types.isMarkoPlaceholder(child)) {
+            write2`${callRuntime("escapeScript", child.value)}`;
+          }
+        }
+      } else {
+        const templateQuasis = [];
+        const templateExpressions = [];
+        let currentQuasi = "";
+        let referencePlaceholder;
+        for (const child of tag.node.body.body) {
+          if (import_compiler39.types.isMarkoText(child)) {
+            currentQuasi += child.value;
+          } else if (import_compiler39.types.isMarkoPlaceholder(child)) {
+            referencePlaceholder ||= child;
+            templateQuasis.push(import_compiler39.types.templateElement({ raw: currentQuasi }));
+            templateExpressions.push(child.value);
+            currentQuasi = "";
+          }
+        }
+        if (!referencePlaceholder) {
+          write2`${currentQuasi}`;
         } else {
+          templateQuasis.push(import_compiler39.types.templateElement({ raw: currentQuasi }));
           addStatement(
             "render",
-            section,
-            tagExtra.referencedBindings,
+            getSection(tag),
+            referencePlaceholder.value.extra?.referencedBindings,
             import_compiler39.types.expressionStatement(
               callRuntime(
-                "attrs",
-                scopeIdentifier,
-                visitAccessor,
-                spreadExpression
+                "textContent",
+                import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                import_compiler39.types.templateLiteral(templateQuasis, templateExpressions)
               )
             )
           );
         }
-        addStatement(
-          "effect",
-          section,
-          tagExtra.referencedBindings,
-          import_compiler39.types.expressionStatement(
-            callRuntime("attrsEvents", scopeIdentifier, visitAccessor)
-          ),
-          false
-        );
-      }
-    }
-    write2`>`;
-    enter2(tag);
-    if (isOutputHTML()) {
-      for (const child of tag.node.body.body) {
-        if (import_compiler39.types.isMarkoText(child)) {
-          write2`${child.value}`;
-        } else if (import_compiler39.types.isMarkoPlaceholder(child)) {
-          write2`${callRuntime("escapeScript", child.value)}`;
-        }
       }
-    } else {
-      const templateQuasis = [];
-      const templateExpressions = [];
-      let currentQuasi = "";
-      let referencePlaceholder;
-      for (const child of tag.node.body.body) {
-        if (import_compiler39.types.isMarkoText(child)) {
-          currentQuasi += child.value;
-        } else if (import_compiler39.types.isMarkoPlaceholder(child)) {
-          referencePlaceholder ||= child;
-          templateQuasis.push(import_compiler39.types.templateElement({ raw: currentQuasi }));
-          templateExpressions.push(child.value);
-          currentQuasi = "";
-        }
-      }
-      if (!referencePlaceholder) {
-        write2`${currentQuasi}`;
-      } else {
-        templateQuasis.push(import_compiler39.types.templateElement({ raw: currentQuasi }));
-        addStatement(
-          "render",
-          getSection(tag),
-          referencePlaceholder.value.extra?.referencedBindings,
-          import_compiler39.types.expressionStatement(
-            callRuntime(
-              "textContent",
-              import_compiler39.types.memberExpression(scopeIdentifier, visitAccessor, true),
-              import_compiler39.types.templateLiteral(templateQuasis, templateExpressions)
-            )
-          )
-        );
+      write2`</script>`;
+      if (nodeRef2) {
+        markNode(tag, nodeRef2);
       }
+      exit2(tag);
+      tag.remove();
     }
-    write2`</script>`;
-    if (nodeRef2) {
-      markNode(tag, nodeRef2);
-    }
-    exit2(tag);
-    tag.remove();
   },
   "@async": "#html-async",
   "@crossorigin": "#html-crossorigin",
@@ -7088,124 +7112,167 @@ var html_style_default = {
       }
     }
   },
-  translate(tag) {
-    const tagExtra = tag.node.extra;
-    const nodeRef2 = tagExtra[kNativeTagBinding];
-    const isHTML = isOutputHTML();
-    const write2 = writeTo(tag);
-    const section = getSection(tag);
-    const hasVar = !!tag.node.var;
-    if (hasVar) {
-      const getterId = tagExtra[kGetterId4];
-      if (isHTML) {
-        const varName = tag.node.var.name;
-        const references = tag.scope.getBinding(varName).referencePaths;
-        for (const reference of references) {
-          serializeOwners(getSection(reference), section);
-        }
-        translateVar(
-          tag,
-          callRuntime(
-            "nodeRef",
-            getterId && getScopeIdIdentifier(section),
-            getterId && import_compiler40.types.stringLiteral(getterId)
-          )
-        );
-      } else {
-        const varName = tag.node.var.name;
-        const references = tag.scope.getBinding(varName).referencePaths;
-        let getterFnIdentifier;
-        if (getterId) {
-          getterFnIdentifier = (0, import_compiler40.getProgram)().scope.generateUidIdentifier(
-            `get_${varName}`
-          );
-          (0, import_compiler40.getProgram)().node.body.push(
-            import_compiler40.types.variableDeclaration("const", [
-              import_compiler40.types.variableDeclarator(
-                getterFnIdentifier,
-                callRuntime(
-                  "nodeRef",
-                  import_compiler40.types.stringLiteral(getterId),
-                  getScopeAccessorLiteral(nodeRef2)
-                )
-              )
-            ])
+  translate: {
+    enter(tag) {
+      const tagExtra = tag.node.extra;
+      const nodeRef2 = tagExtra[kNativeTagBinding];
+      const isHTML = isOutputHTML();
+      const write2 = writeTo(tag);
+      const section = getSection(tag);
+      const hasVar = !!tag.node.var;
+      if (hasVar) {
+        const getterId = tagExtra[kGetterId4];
+        if (isHTML) {
+          const varName = tag.node.var.name;
+          const references = tag.scope.getBinding(varName).referencePaths;
+          for (const reference of references) {
+            serializeOwners(getSection(reference), section);
+          }
+          translateVar(
+            tag,
+            callRuntime(
+              "nodeRef",
+              getterId && getScopeIdIdentifier(section),
+              getterId && import_compiler40.types.stringLiteral(getterId)
+            )
           );
-        }
-        for (const reference of references) {
-          const referenceSection = getSection(reference);
-          if (isInvokedFunction(reference)) {
-            reference.parentPath.replaceWith(
-              import_compiler40.types.expressionStatement(
-                createScopeReadExpression(referenceSection, nodeRef2)
-              )
+        } else {
+          const varName = tag.node.var.name;
+          const references = tag.scope.getBinding(varName).referencePaths;
+          let getterFnIdentifier;
+          if (getterId) {
+            getterFnIdentifier = (0, import_compiler40.getProgram)().scope.generateUidIdentifier(
+              `get_${varName}`
             );
-          } else if (getterFnIdentifier) {
-            reference.replaceWith(
-              import_compiler40.types.callExpression(getterFnIdentifier, [
-                getScopeExpression(referenceSection, getSection(tag))
+            (0, import_compiler40.getProgram)().node.body.push(
+              import_compiler40.types.variableDeclaration("const", [
+                import_compiler40.types.variableDeclarator(
+                  getterFnIdentifier,
+                  callRuntime(
+                    "nodeRef",
+                    import_compiler40.types.stringLiteral(getterId),
+                    getScopeAccessorLiteral(nodeRef2)
+                  )
+                )
               ])
             );
           }
+          for (const reference of references) {
+            const referenceSection = getSection(reference);
+            if (isInvokedFunction(reference)) {
+              reference.parentPath.replaceWith(
+                import_compiler40.types.expressionStatement(
+                  createScopeReadExpression(referenceSection, nodeRef2)
+                )
+              );
+            } else if (getterFnIdentifier) {
+              reference.replaceWith(
+                import_compiler40.types.callExpression(getterFnIdentifier, [
+                  getScopeExpression(referenceSection, getSection(tag))
+                ])
+              );
+            }
+          }
         }
       }
-    }
-    let visitAccessor;
-    if (nodeRef2) {
-      visitAccessor = getScopeAccessorLiteral(nodeRef2);
-      visit(tag, 32 /* Get */);
-    }
-    write2`<style`;
-    const usedAttrs = getUsedAttrs3(tag.node);
-    const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
-    for (const attr2 of staticAttrs) {
-      const { name: name2, value } = attr2;
-      const { confident, computed } = value.extra || {};
-      const valueReferences = value.extra?.referencedBindings;
-      switch (name2) {
-        case "class":
-        case "style": {
-          const helper = `${name2}Attr`;
-          if (confident) {
-            write2`${getHTMLRuntime()[helper](computed)}`;
-          } else if (isHTML) {
-            write2`${callRuntime(helper, value)}`;
-          } else {
-            addStatement(
-              "render",
-              section,
-              valueReferences,
-              import_compiler40.types.expressionStatement(
-                callRuntime(
-                  helper,
-                  import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  value
+      let visitAccessor;
+      if (nodeRef2) {
+        visitAccessor = getScopeAccessorLiteral(nodeRef2);
+        visit(tag, 32 /* Get */);
+      }
+      write2`<style`;
+      const usedAttrs = getUsedAttrs3(tag.node);
+      const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
+      for (const attr2 of staticAttrs) {
+        const { name: name2, value } = attr2;
+        const { confident, computed } = value.extra || {};
+        const valueReferences = value.extra?.referencedBindings;
+        switch (name2) {
+          case "class":
+          case "style": {
+            const helper = `${name2}Attr`;
+            if (confident) {
+              write2`${getHTMLRuntime()[helper](computed)}`;
+            } else if (isHTML) {
+              write2`${callRuntime(helper, value)}`;
+            } else {
+              addStatement(
+                "render",
+                section,
+                valueReferences,
+                import_compiler40.types.expressionStatement(
+                  callRuntime(
+                    helper,
+                    import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    value
+                  )
                 )
-              )
-            );
+              );
+            }
+            break;
           }
-          break;
-        }
-        default:
-          if (confident) {
-            write2`${getHTMLRuntime().attr(name2, computed)}`;
-          } else if (isHTML) {
-            if (isEventHandler(name2)) {
-              addHTMLEffectCall(section, valueReferences);
+          default:
+            if (confident) {
+              write2`${getHTMLRuntime().attr(name2, computed)}`;
+            } else if (isHTML) {
+              if (isEventHandler(name2)) {
+                addHTMLEffectCall(section, valueReferences);
+              } else {
+                write2`${callRuntime("attr", import_compiler40.types.stringLiteral(name2), value)}`;
+              }
+            } else if (isEventHandler(name2)) {
+              addStatement(
+                "effect",
+                section,
+                valueReferences,
+                import_compiler40.types.expressionStatement(
+                  callRuntime(
+                    "on",
+                    import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler40.types.stringLiteral(getEventHandlerName(name2)),
+                    value
+                  )
+                )
+              );
             } else {
-              write2`${callRuntime("attr", import_compiler40.types.stringLiteral(name2), value)}`;
+              addStatement(
+                "render",
+                section,
+                valueReferences,
+                import_compiler40.types.expressionStatement(
+                  callRuntime(
+                    "attr",
+                    import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                    import_compiler40.types.stringLiteral(name2),
+                    value
+                  )
+                )
+              );
             }
-          } else if (isEventHandler(name2)) {
+            break;
+        }
+      }
+      if (spreadExpression) {
+        if (isHTML) {
+          addHTMLEffectCall(section, tagExtra.referencedBindings);
+          if (skipExpression) {
+            write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler40.types.stringLiteral("style"))}`;
+          } else {
+            write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler40.types.stringLiteral("style"))}`;
+          }
+        } else {
+          if (skipExpression) {
             addStatement(
-              "effect",
+              "render",
               section,
-              valueReferences,
+              tagExtra.referencedBindings,
               import_compiler40.types.expressionStatement(
                 callRuntime(
-                  "on",
-                  import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler40.types.stringLiteral(getEventHandlerName(name2)),
-                  value
+                  "partialAttrs",
+                  scopeIdentifier,
+                  visitAccessor,
+                  spreadExpression,
+                  skipExpression
                 )
               )
             );
@@ -7213,119 +7280,84 @@ var html_style_default = {
             addStatement(
               "render",
               section,
-              valueReferences,
+              tagExtra.referencedBindings,
               import_compiler40.types.expressionStatement(
                 callRuntime(
-                  "attr",
-                  import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
-                  import_compiler40.types.stringLiteral(name2),
-                  value
+                  "attrs",
+                  scopeIdentifier,
+                  visitAccessor,
+                  spreadExpression
                 )
               )
             );
           }
-          break;
-      }
-    }
-    if (spreadExpression) {
-      if (isHTML) {
-        addHTMLEffectCall(section, tagExtra.referencedBindings);
-        if (skipExpression) {
-          write2`${callRuntime("partialAttrs", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler40.types.stringLiteral("style"))}`;
-        } else {
-          write2`${callRuntime("attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(section), import_compiler40.types.stringLiteral("style"))}`;
-        }
-      } else {
-        if (skipExpression) {
           addStatement(
-            "render",
+            "effect",
             section,
             tagExtra.referencedBindings,
             import_compiler40.types.expressionStatement(
-              callRuntime(
-                "partialAttrs",
-                scopeIdentifier,
-                visitAccessor,
-                spreadExpression,
-                skipExpression
-              )
-            )
+              callRuntime("attrsEvents", scopeIdentifier, visitAccessor)
+            ),
+            false
           );
+        }
+      }
+    },
+    exit(tag) {
+      const tagExtra = tag.node.extra;
+      const nodeRef2 = tagExtra[kNativeTagBinding];
+      const write2 = writeTo(tag);
+      const visitAccessor = nodeRef2 && getScopeAccessorLiteral(nodeRef2);
+      write2`>`;
+      enter2(tag);
+      if (isOutputHTML()) {
+        for (const child of tag.node.body.body) {
+          if (import_compiler40.types.isMarkoText(child)) {
+            write2`${child.value}`;
+          } else if (import_compiler40.types.isMarkoPlaceholder(child)) {
+            write2`${callRuntime("escapeStyle", child.value)}`;
+          }
+        }
+      } else {
+        const templateQuasis = [];
+        const templateExpressions = [];
+        let currentQuasi = "";
+        let referencePlaceholder;
+        for (const child of tag.node.body.body) {
+          if (import_compiler40.types.isMarkoText(child)) {
+            currentQuasi += child.value;
+          } else if (import_compiler40.types.isMarkoPlaceholder(child)) {
+            referencePlaceholder ||= child;
+            templateQuasis.push(import_compiler40.types.templateElement({ raw: currentQuasi }));
+            templateExpressions.push(child.value);
+            currentQuasi = "";
+          }
+        }
+        if (!referencePlaceholder) {
+          write2`${currentQuasi}`;
         } else {
+          templateQuasis.push(import_compiler40.types.templateElement({ raw: currentQuasi }));
           addStatement(
             "render",
-            section,
-            tagExtra.referencedBindings,
+            getSection(tag),
+            referencePlaceholder.value.extra?.referencedBindings,
             import_compiler40.types.expressionStatement(
               callRuntime(
-                "attrs",
-                scopeIdentifier,
-                visitAccessor,
-                spreadExpression
+                "textContent",
+                import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
+                import_compiler40.types.templateLiteral(templateQuasis, templateExpressions)
               )
             )
           );
         }
-        addStatement(
-          "effect",
-          section,
-          tagExtra.referencedBindings,
-          import_compiler40.types.expressionStatement(
-            callRuntime("attrsEvents", scopeIdentifier, visitAccessor)
-          ),
-          false
-        );
-      }
-    }
-    write2`>`;
-    enter2(tag);
-    if (isOutputHTML()) {
-      for (const child of tag.node.body.body) {
-        if (import_compiler40.types.isMarkoText(child)) {
-          write2`${child.value}`;
-        } else if (import_compiler40.types.isMarkoPlaceholder(child)) {
-          write2`${callRuntime("escapeStyle", child.value)}`;
-        }
-      }
-    } else {
-      const templateQuasis = [];
-      const templateExpressions = [];
-      let currentQuasi = "";
-      let referencePlaceholder;
-      for (const child of tag.node.body.body) {
-        if (import_compiler40.types.isMarkoText(child)) {
-          currentQuasi += child.value;
-        } else if (import_compiler40.types.isMarkoPlaceholder(child)) {
-          referencePlaceholder ||= child;
-          templateQuasis.push(import_compiler40.types.templateElement({ raw: currentQuasi }));
-          templateExpressions.push(child.value);
-          currentQuasi = "";
-        }
       }
-      if (!referencePlaceholder) {
-        write2`${currentQuasi}`;
-      } else {
-        templateQuasis.push(import_compiler40.types.templateElement({ raw: currentQuasi }));
-        addStatement(
-          "render",
-          getSection(tag),
-          referencePlaceholder.value.extra?.referencedBindings,
-          import_compiler40.types.expressionStatement(
-            callRuntime(
-              "textContent",
-              import_compiler40.types.memberExpression(scopeIdentifier, visitAccessor, true),
-              import_compiler40.types.templateLiteral(templateQuasis, templateExpressions)
-            )
-          )
-        );
+      write2`</style>`;
+      if (nodeRef2) {
+        markNode(tag, nodeRef2);
       }
+      exit2(tag);
+      tag.remove();
     }
-    write2`</style>`;
-    if (nodeRef2) {
-      markNode(tag, nodeRef2);
-    }
-    exit2(tag);
-    tag.remove();
   },
   "@disabled": "#html-disabled",
   "@media": "#html-media",
@@ -8142,6 +8174,8 @@ var script_default = {
 };
 function isAwaitExpression(node) {
   switch (node.type) {
+    case "ForOfStatement":
+      return node.await;
     case "FunctionDeclaration":
     case "FunctionExpression":
     case "ArrowFunctionExpression":
@@ -8620,12 +8654,29 @@ var import_declaration_default = {
 };
 
 // src/translator/visitors/placeholder.ts
+var import_compiler54 = require("@marko/compiler");
+
+// src/translator/util/is-non-html-text.ts
 var import_compiler53 = require("@marko/compiler");
+function isNonHTMLText(placeholder) {
+  const parentTag = placeholder.parentPath.isMarkoTagBody() && placeholder.parentPath.parentPath;
+  if (parentTag && isCoreTag(parentTag)) {
+    switch (parentTag.node.name.value) {
+      case "html-comment":
+      case "html-script":
+      case "html-style":
+        return true;
+    }
+  }
+  return false;
+}
+
+// src/translator/visitors/placeholder.ts
 var kBinding = Symbol("placeholder node binding");
 var kSiblingText = Symbol("placeholder has sibling text");
 var placeholder_default = {
   analyze(placeholder) {
-    if (isNonHTMLPlaceholder(placeholder)) return;
+    if (isNonHTMLText(placeholder)) return;
     const { node } = placeholder;
     const { confident, computed } = evaluate(node.value);
     if (!(confident && (node.escape || isVoid2(computed)))) {
@@ -8641,6 +8692,7 @@ var placeholder_default = {
   },
   translate: {
     exit(placeholder) {
+      if (isNonHTMLText(placeholder)) return;
       const { node } = placeholder;
       const { value } = node;
       const { confident, computed, referencedBindings } = evaluate(value);
@@ -8680,10 +8732,10 @@ var placeholder_default = {
             "render",
             getSection(placeholder),
             value.extra?.referencedBindings,
-            import_compiler53.types.expressionStatement(
+            import_compiler54.types.expressionStatement(
               method === "data" ? callRuntime(
                 "data",
-                import_compiler53.types.memberExpression(
+                import_compiler54.types.memberExpression(
                   scopeIdentifier,
                   getScopeAccessorLiteral(nodeBinding),
                   true
@@ -8720,7 +8772,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!prev.node && import_compiler53.types.isProgram(placeholder.parentPath)) {
+  if (!prev.node && import_compiler54.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 1 /* Before */;
   }
   let next = placeholder.getNextSibling();
@@ -8737,29 +8789,17 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!next.node && import_compiler53.types.isProgram(placeholder.parentPath)) {
+  if (!next.node && import_compiler54.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 2 /* After */;
   }
   return placeholderExtra[kSiblingText] = 0 /* None */;
 }
-function isNonHTMLPlaceholder(placeholder) {
-  const parentTag = placeholder.parentPath.isMarkoTagBody() && placeholder.parentPath.parentPath;
-  if (parentTag && isCoreTag(parentTag)) {
-    switch (parentTag.node.name.value) {
-      case "html-comment":
-      case "html-script":
-      case "html-style":
-        return true;
-    }
-  }
-  return false;
-}
 function isVoid2(value) {
   return value == null || value === false;
 }
 
 // src/translator/visitors/referenced-identifier.ts
-var import_compiler54 = require("@marko/compiler");
+var import_compiler55 = require("@marko/compiler");
 var abortIdsByExpressionForSection = /* @__PURE__ */ new WeakMap();
 var referenced_identifier_default = {
   migrate(identifier) {
@@ -8767,8 +8807,8 @@ var referenced_identifier_default = {
     if (identifier.scope.hasBinding(name2)) return;
     switch (name2) {
       case "out":
-        if (import_compiler54.types.isMemberExpression(identifier.parent) && import_compiler54.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
-          identifier.parentPath.replaceWith(import_compiler54.types.identifier("$global"));
+        if (import_compiler55.types.isMemberExpression(identifier.parent) && import_compiler55.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
+          identifier.parentPath.replaceWith(import_compiler55.types.identifier("$global"));
         } else {
           throw identifier.buildCodeFrameError(
             "Only `out.global` is supported for compatibility."
@@ -8795,24 +8835,24 @@ var referenced_identifier_default = {
       case "$global":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler54.types.callExpression(importRuntime("$global"), [])
+            import_compiler55.types.callExpression(importRuntime("$global"), [])
           );
         } else {
           identifier.replaceWith(
-            import_compiler54.types.memberExpression(scopeIdentifier, import_compiler54.types.identifier("$global"))
+            import_compiler55.types.memberExpression(scopeIdentifier, import_compiler55.types.identifier("$global"))
           );
         }
         break;
       case "$signal":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler54.types.callExpression(
-              import_compiler54.types.arrowFunctionExpression(
+            import_compiler55.types.callExpression(
+              import_compiler55.types.arrowFunctionExpression(
                 [],
-                import_compiler54.types.blockStatement([
-                  import_compiler54.types.throwStatement(
-                    import_compiler54.types.newExpression(import_compiler54.types.identifier("Error"), [
-                      import_compiler54.types.stringLiteral("Cannot use $signal in a server render.")
+                import_compiler55.types.blockStatement([
+                  import_compiler55.types.throwStatement(
+                    import_compiler55.types.newExpression(import_compiler55.types.identifier("Error"), [
+                      import_compiler55.types.stringLiteral("Cannot use $signal in a server render.")
                     ])
                   )
                 ])
@@ -8838,19 +8878,19 @@ var referenced_identifier_default = {
               "render",
               section,
               exprRoot.node.extra?.referencedBindings,
-              import_compiler54.types.expressionStatement(
-                import_compiler54.types.callExpression(importRuntime("resetAbortSignal"), [
+              import_compiler55.types.expressionStatement(
+                import_compiler55.types.callExpression(importRuntime("resetAbortSignal"), [
                   scopeIdentifier,
-                  import_compiler54.types.numericLiteral(exprId)
+                  import_compiler55.types.numericLiteral(exprId)
                 ])
               ),
               false
             );
           }
           identifier.replaceWith(
-            import_compiler54.types.callExpression(importRuntime("getAbortSignal"), [
+            import_compiler55.types.callExpression(importRuntime("getAbortSignal"), [
               scopeIdentifier,
-              import_compiler54.types.numericLiteral(exprId)
+              import_compiler55.types.numericLiteral(exprId)
             ])
           );
         }
@@ -8890,11 +8930,11 @@ var scriptlet_default = {
 };
 
 // src/translator/visitors/tag/index.ts
-var import_compiler58 = require("@marko/compiler");
+var import_compiler59 = require("@marko/compiler");
 var import_babel_utils43 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/attribute-tag.ts
-var import_compiler55 = require("@marko/compiler");
+var import_compiler56 = require("@marko/compiler");
 var import_babel_utils40 = require("@marko/compiler/babel-utils");
 var attribute_tag_default = {
   analyze: {
@@ -8925,7 +8965,7 @@ var attribute_tag_default = {
 };
 
 // src/translator/visitors/tag/custom-tag.ts
-var import_compiler56 = require("@marko/compiler");
+var import_compiler57 = require("@marko/compiler");
 var import_babel_utils41 = require("@marko/compiler/babel-utils");
 var import_path4 = __toESM(require("path"));
 var kChildScopeBinding = Symbol("custom tag child scope");
@@ -8980,7 +9020,7 @@ var custom_tag_default = {
           tag,
           childProgramExtra?.domExports.input
         );
-        (0, import_compiler56.getProgram)().node.extra.hasInteractiveChild = childProgramExtra?.isInteractive || childProgramExtra?.hasInteractiveChild || false;
+        (0, import_compiler57.getProgram)().node.extra.hasInteractiveChild = childProgramExtra?.isInteractive || childProgramExtra?.hasInteractiveChild || false;
       }
     }
   },
@@ -9007,9 +9047,9 @@ function translateHTML(tag) {
   let tagIdentifier;
   flushInto(tag);
   writeHTMLResumeStatements(tagBody);
-  if (import_compiler56.types.isStringLiteral(node.name)) {
+  if (import_compiler57.types.isStringLiteral(node.name)) {
     const relativePath = getTagRelativePath(tag);
-    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler56.types.identifier(getTemplateContentName()) : (0, import_babel_utils41.importDefault)(tag.hub.file, relativePath, getTagName(tag));
+    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler57.types.identifier(getTemplateContentName()) : (0, import_babel_utils41.importDefault)(tag.hub.file, relativePath, getTagName(tag));
   } else {
     tagIdentifier = node.name;
   }
@@ -9027,8 +9067,8 @@ function translateHTML(tag) {
       childScopeBinding?.name
     );
     tag.insertBefore(
-      import_compiler56.types.variableDeclaration("const", [
-        import_compiler56.types.variableDeclarator(peekScopeId, callRuntime("peekNextScope"))
+      import_compiler57.types.variableDeclaration("const", [
+        import_compiler57.types.variableDeclarator(peekScopeId, callRuntime("peekNextScope"))
       ])
     );
     setSerializedProperty(
@@ -9039,13 +9079,13 @@ function translateHTML(tag) {
     );
     if (tagVar) {
       statements.push(
-        import_compiler56.types.expressionStatement(
+        import_compiler57.types.expressionStatement(
           callRuntime(
             "setTagVar",
             getScopeIdIdentifier(section),
             getScopeAccessorLiteral(tag.node.extra[kChildOffsetScopeBinding]),
             peekScopeId,
-            import_compiler56.types.stringLiteral(
+            import_compiler57.types.stringLiteral(
               getResumeRegisterId(
                 section,
                 node.var.extra?.binding,
@@ -9065,8 +9105,8 @@ function translateHTML(tag) {
       const contentExpression = contentProp.value;
       contentProp.value = contentId = tag.scope.generateUidIdentifier("content");
       const [contentPath] = tag.insertBefore(
-        import_compiler56.types.variableDeclaration("const", [
-          import_compiler56.types.variableDeclarator(
+        import_compiler57.types.variableDeclaration("const", [
+          import_compiler57.types.variableDeclarator(
             contentId,
             // TODO: only register if needed (child template analysis)
             contentExpression
@@ -9080,13 +9120,13 @@ function translateHTML(tag) {
       propsToExpression(properties)
     );
     if (tagVar) {
-      translateVar(tag, import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0)), "let");
-      renderTagExpr = import_compiler56.types.assignmentExpression("=", tagVar, renderTagExpr);
+      translateVar(tag, import_compiler57.types.unaryExpression("void", import_compiler57.types.numericLiteral(0)), "let");
+      renderTagExpr = import_compiler57.types.assignmentExpression("=", tagVar, renderTagExpr);
     }
     statements.push(
-      import_compiler56.types.ifStatement(
+      import_compiler57.types.ifStatement(
         tagIdentifier,
-        import_compiler56.types.expressionStatement(renderTagExpr),
+        import_compiler57.types.expressionStatement(renderTagExpr),
         contentId && callStatement(contentId)
       )
     );
@@ -9112,7 +9152,7 @@ function translateDOM(tag) {
   const childScopeBinding = extra[kChildScopeBinding];
   const write2 = writeTo(tag);
   const { file } = tag.hub;
-  const tagName = import_compiler56.types.isIdentifier(node.name) ? node.name.name : import_compiler56.types.isStringLiteral(node.name) ? node.name.value : "tag";
+  const tagName = import_compiler57.types.isIdentifier(node.name) ? node.name.name : import_compiler57.types.isStringLiteral(node.name) ? node.name.value : "tag";
   const relativePath = getTagRelativePath(tag);
   const childFile = (0, import_babel_utils41.loadFileForTag)(tag);
   const childExports = childFile.ast.program.extra.domExports;
@@ -9144,7 +9184,7 @@ function translateDOM(tag) {
     );
     source.register = true;
     source.buildAssignment = (valueSection, value) => {
-      return import_compiler56.types.callExpression(importRuntime("tagVarSignalChange"), [
+      return import_compiler57.types.callExpression(importRuntime("tagVarSignalChange"), [
         createScopeReadExpression(valueSection, childScopeBinding),
         value
       ]);
@@ -9153,7 +9193,7 @@ function translateDOM(tag) {
       "render",
       tagSection,
       void 0,
-      import_compiler56.types.expressionStatement(
+      import_compiler57.types.expressionStatement(
         callRuntime(
           "setTagVar",
           scopeIdentifier,
@@ -9167,8 +9207,8 @@ function translateDOM(tag) {
     "render",
     tagSection,
     void 0,
-    import_compiler56.types.expressionStatement(
-      import_compiler56.types.callExpression(tagIdentifier, [
+    import_compiler57.types.expressionStatement(
+      import_compiler57.types.callExpression(tagIdentifier, [
         createScopeReadExpression(tagSection, childScopeBinding)
       ])
     )
@@ -9181,7 +9221,7 @@ function getTagRelativePath(tag) {
     hub: { file }
   } = tag;
   let relativePath;
-  if (import_compiler56.types.isStringLiteral(node.name)) {
+  if (import_compiler57.types.isStringLiteral(node.name)) {
     const template = (0, import_babel_utils41.getTagTemplate)(tag);
     relativePath = template && (0, import_babel_utils41.resolveRelativePath)(file, template);
   } else if (node.extra?.tagNameImported) {
@@ -9274,7 +9314,7 @@ function analyzeAttrs(rootTagExtra, section, tag, templateExport) {
   let spreadReferenceNodes;
   for (let i = attributes.length; i--; ) {
     const attr2 = attributes[i];
-    if (import_compiler56.types.isMarkoAttribute(attr2)) {
+    if (import_compiler57.types.isMarkoAttribute(attr2)) {
       if (seen.has(attr2.name) || !templateExport.props[attr2.name]) {
         dropReferences(attr2.value);
         continue;
@@ -9283,7 +9323,7 @@ function analyzeAttrs(rootTagExtra, section, tag, templateExport) {
     }
     if (spreadReferenceNodes) {
       spreadReferenceNodes.push(attr2.value);
-    } else if (import_compiler56.types.isMarkoSpreadAttribute(attr2)) {
+    } else if (import_compiler57.types.isMarkoSpreadAttribute(attr2)) {
       spreadReferenceNodes = [attr2.value];
     } else {
       rootTagExtra[kChildAttrExprs].add(attr2.value.extra ??= {});
@@ -9308,7 +9348,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       // but we should probably ensure all other references are dropped in this case before we do that.
       tag.node.extra?.referencedBindings,
       identifierToSignal(tagInputIdentifier),
-      import_compiler56.types.isSpreadElement(arg) ? import_compiler56.types.memberExpression(arg.argument, import_compiler56.types.numericLiteral(0), true) : arg,
+      import_compiler57.types.isSpreadElement(arg) ? import_compiler57.types.memberExpression(arg.argument, import_compiler57.types.numericLiteral(0), true) : arg,
       createScopeReadExpression(info.tagSection, info.childScopeBinding)
     );
     return;
@@ -9356,7 +9396,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         } else {
           attrTagCallsForTag.set(
             attrTagName,
-            translatedProps = import_compiler56.types.parenthesizedExpression(
+            translatedProps = import_compiler57.types.parenthesizedExpression(
               callRuntime("attrTag", translatedProps)
             )
           );
@@ -9441,7 +9481,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
           childAttrExports.id,
           `${importAlias}_${attrTagMeta.name}`
         );
-        decls.push(import_compiler56.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
+        decls.push(import_compiler57.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
         addValue(
           info.tagSection,
           referencedBindings,
@@ -9451,7 +9491,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         );
       }
       addStatement("render", info.tagSection, referencedBindings, [
-        import_compiler56.types.variableDeclaration("let", decls),
+        import_compiler57.types.variableDeclaration("let", decls),
         ...statements
       ]);
     }
@@ -9471,7 +9511,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
         void 0,
         // TODO: pretty sure content needs to have the reference group of it's param defaults.
         identifierToSignal(contentExportIdentifier),
-        import_compiler56.types.callExpression(import_compiler56.types.identifier(bodySection.name), [scopeIdentifier]),
+        import_compiler57.types.callExpression(import_compiler57.types.identifier(bodySection.name), [scopeIdentifier]),
         createScopeReadExpression(info.tagSection, info.childScopeBinding)
       );
     }
@@ -9481,7 +9521,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
   let spreadProps;
   for (let i = attributes.length; i--; ) {
     const attr2 = attributes[i];
-    if (import_compiler56.types.isMarkoAttribute(attr2)) {
+    if (import_compiler57.types.isMarkoAttribute(attr2)) {
       const childAttrExports = templateExport.props[attr2.name];
       if (!childAttrExports || seen.has(attr2.name)) continue;
       seen.add(attr2.name);
@@ -9491,9 +9531,9 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       }
       staticAttrs.push(attr2);
     } else if (spreadProps) {
-      spreadProps.push(import_compiler56.types.spreadElement(attr2.value));
+      spreadProps.push(import_compiler57.types.spreadElement(attr2.value));
     } else {
-      spreadProps = [import_compiler56.types.spreadElement(attr2.value)];
+      spreadProps = [import_compiler57.types.spreadElement(attr2.value)];
     }
   }
   for (const attr2 of staticAttrs.reverse()) {
@@ -9522,8 +9562,8 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
       spreadProps.reverse();
       getMissingPropValue = (name2) => toMemberExpression(spreadId, name2);
       addStatement("render", info.tagSection, referencedBindings, [
-        import_compiler56.types.variableDeclaration("const", [
-          import_compiler56.types.variableDeclarator(spreadId, propsToExpression(spreadProps))
+        import_compiler57.types.variableDeclaration("const", [
+          import_compiler57.types.variableDeclarator(spreadId, propsToExpression(spreadProps))
         ])
       ]);
     }
@@ -9547,7 +9587,7 @@ function writeAttrsToExports(tag, templateExport, importAlias, info) {
 }
 function importOrSelfReferenceName(file, request, name2, nameHint) {
   if (isCircularRequest(file, request)) {
-    return import_compiler56.types.identifier(name2);
+    return import_compiler57.types.identifier(name2);
   }
   return (0, import_babel_utils41.importNamed)(file, request, name2, nameHint);
 }
@@ -9556,10 +9596,10 @@ function isCircularRequest(file, request) {
   return request === filename || request[0] === "." && import_path4.default.resolve(filename, "..", request) === filename;
 }
 function callStatement(id, ...args) {
-  return import_compiler56.types.expressionStatement(callExpression(id, ...args));
+  return import_compiler57.types.expressionStatement(callExpression(id, ...args));
 }
 function callExpression(id, ...args) {
-  return import_compiler56.types.callExpression(id, args.filter(Boolean));
+  return import_compiler57.types.callExpression(id, args.filter(Boolean));
 }
 function identifierToSignal(identifier) {
   return {
@@ -9568,14 +9608,14 @@ function identifierToSignal(identifier) {
   };
 }
 function buildUndefined2() {
-  return import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0));
+  return import_compiler57.types.unaryExpression("void", import_compiler57.types.numericLiteral(0));
 }
 function always() {
   return true;
 }
 
 // src/translator/visitors/tag/dynamic-tag.ts
-var import_compiler57 = require("@marko/compiler");
+var import_compiler58 = require("@marko/compiler");
 var import_babel_utils42 = require("@marko/compiler/babel-utils");
 var kDOMBinding3 = Symbol("dynamic tag dom binding");
 var kChildOffsetScopeBinding2 = Symbol("custom tag scope offset");
@@ -9631,7 +9671,7 @@ var dynamic_tag_default = {
       const isClassAPI = tagExtra.featureType === "class";
       const referencedBindings = tagExtra.referencedBindings;
       let tagExpression = node.name;
-      if (import_compiler57.types.isStringLiteral(tagExpression)) {
+      if (import_compiler58.types.isStringLiteral(tagExpression)) {
         tagExpression = (0, import_babel_utils42.importDefault)(
           tag.hub.file,
           getTagRelativePath(tag),
@@ -9640,15 +9680,15 @@ var dynamic_tag_default = {
       }
       if (isClassAPI) {
         if (isOutputHTML()) {
-          (0, import_compiler57.getProgram)().node.body.push(
-            import_compiler57.types.markoScriptlet(
+          (0, import_compiler58.getProgram)().node.body.push(
+            import_compiler58.types.markoScriptlet(
               [
-                import_compiler57.types.expressionStatement(
-                  import_compiler57.types.callExpression(
+                import_compiler58.types.expressionStatement(
+                  import_compiler58.types.callExpression(
                     (0, import_babel_utils42.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
                     [
-                      import_compiler57.types.identifier(tagExpression.name),
-                      import_compiler57.types.stringLiteral((0, import_babel_utils42.loadFileForTag)(tag).metadata.marko.id)
+                      import_compiler58.types.identifier(tagExpression.name),
+                      import_compiler58.types.stringLiteral((0, import_babel_utils42.loadFileForTag)(tag).metadata.marko.id)
                     ]
                   )
                 )
@@ -9657,12 +9697,12 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          (0, import_compiler57.getProgram)().node.body.push(
-            import_compiler57.types.expressionStatement(
+          (0, import_compiler58.getProgram)().node.body.push(
+            import_compiler58.types.expressionStatement(
               callRuntime(
                 "register",
-                import_compiler57.types.stringLiteral((0, import_babel_utils42.loadFileForTag)(tag).metadata.marko.id),
-                import_compiler57.types.identifier(tagExpression.name)
+                import_compiler58.types.stringLiteral((0, import_babel_utils42.loadFileForTag)(tag).metadata.marko.id),
+                import_compiler58.types.identifier(tagExpression.name)
               )
             )
           );
@@ -9682,7 +9722,7 @@ var dynamic_tag_default = {
           hasMultipleArgs = true;
           args.push(propsToExpression(properties));
         } else {
-          hasMultipleArgs = node.arguments.length > 1 || import_compiler57.types.isSpreadElement(node.arguments[0]);
+          hasMultipleArgs = node.arguments.length > 1 || import_compiler58.types.isSpreadElement(node.arguments[0]);
         }
       } else {
         const contentProp = getTranslatedBodyContentProperty(properties);
@@ -9702,35 +9742,35 @@ var dynamic_tag_default = {
           getScopeIdIdentifier(section),
           getScopeAccessorLiteral(nodeRef2),
           tagExpression,
-          import_compiler57.types.arrayExpression(args),
-          import_compiler57.types.numericLiteral(0),
-          import_compiler57.types.numericLiteral(1),
-          serializeReason ? import_compiler57.types.numericLiteral(1) : void 0
+          import_compiler58.types.arrayExpression(args),
+          import_compiler58.types.numericLiteral(0),
+          import_compiler58.types.numericLiteral(1),
+          serializeReason ? import_compiler58.types.numericLiteral(1) : void 0
         ) : callRuntime(
           "dynamicTag",
           getScopeIdIdentifier(section),
           getScopeAccessorLiteral(nodeRef2),
           tagExpression,
           args[0],
-          args[1] || (serializeReason ? import_compiler57.types.numericLiteral(0) : void 0),
-          serializeReason ? import_compiler57.types.numericLiteral(0) : void 0,
-          serializeReason ? import_compiler57.types.numericLiteral(1) : void 0
+          args[1] || (serializeReason ? import_compiler58.types.numericLiteral(0) : void 0),
+          serializeReason ? import_compiler58.types.numericLiteral(0) : void 0,
+          serializeReason ? import_compiler58.types.numericLiteral(1) : void 0
         );
         if (node.var) {
-          const dynamicScopeIdentifier = (0, import_compiler57.getProgram)().scope.generateUidIdentifier("dynamicScope");
+          const dynamicScopeIdentifier = (0, import_compiler58.getProgram)().scope.generateUidIdentifier("dynamicScope");
           statements.push(
-            import_compiler57.types.variableDeclaration("const", [
-              import_compiler57.types.variableDeclarator(
+            import_compiler58.types.variableDeclaration("const", [
+              import_compiler58.types.variableDeclarator(
                 dynamicScopeIdentifier,
                 callRuntime("peekNextScope")
               )
             ])
           );
           statements.push(
-            import_compiler57.types.variableDeclaration("const", [
-              import_compiler57.types.variableDeclarator(node.var, dynamicTagExpr)
+            import_compiler58.types.variableDeclaration("const", [
+              import_compiler58.types.variableDeclarator(node.var, dynamicTagExpr)
             ]),
-            import_compiler57.types.expressionStatement(
+            import_compiler58.types.expressionStatement(
               callRuntime(
                 "setTagVar",
                 getScopeIdIdentifier(section),
@@ -9738,7 +9778,7 @@ var dynamic_tag_default = {
                   tag.node.extra[kChildOffsetScopeBinding2]
                 ),
                 dynamicScopeIdentifier,
-                import_compiler57.types.stringLiteral(
+                import_compiler58.types.stringLiteral(
                   getResumeRegisterId(
                     section,
                     node.var.extra?.binding,
@@ -9750,7 +9790,7 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          statements.push(import_compiler57.types.expressionStatement(dynamicTagExpr));
+          statements.push(import_compiler58.types.expressionStatement(dynamicTagExpr));
         }
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -9767,10 +9807,10 @@ var dynamic_tag_default = {
           );
           tagVarSignal.register = true;
           tagVarSignal.buildAssignment = (valueSection, value) => {
-            return import_compiler57.types.callExpression(importRuntime("tagVarSignalChange"), [
-              import_compiler57.types.memberExpression(
+            return import_compiler58.types.callExpression(importRuntime("tagVarSignalChange"), [
+              import_compiler58.types.memberExpression(
                 getScopeExpression(tagVarSignal.section, valueSection),
-                import_compiler57.types.stringLiteral(
+                import_compiler58.types.stringLiteral(
                   getAccessorPrefix().ConditionalScope + getScopeAccessor(nodeRef2)
                 ),
                 true
@@ -9783,19 +9823,19 @@ var dynamic_tag_default = {
           return callRuntime(
             "dynamicTag",
             getScopeAccessorLiteral(nodeRef2),
-            bodySection && import_compiler57.types.identifier(bodySection.name),
-            tagVarSignal ? import_compiler57.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
-            hasMultipleArgs && import_compiler57.types.numericLiteral(1)
+            bodySection && import_compiler58.types.identifier(bodySection.name),
+            tagVarSignal ? import_compiler58.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
+            hasMultipleArgs && import_compiler58.types.numericLiteral(1)
           );
         };
         if (args.length) {
-          const argsOrInput = hasMultipleArgs ? import_compiler57.types.arrayExpression(args) : args[0];
-          if (!import_compiler57.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
+          const argsOrInput = hasMultipleArgs ? import_compiler58.types.arrayExpression(args) : args[0];
+          if (!import_compiler58.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
             signal.extraArgs = [
-              import_compiler57.types.arrowFunctionExpression(
+              import_compiler58.types.arrowFunctionExpression(
                 [],
-                statements.length ? import_compiler57.types.blockStatement(
-                  statements.concat(import_compiler57.types.returnStatement(argsOrInput))
+                statements.length ? import_compiler58.types.blockStatement(
+                  statements.concat(import_compiler58.types.returnStatement(argsOrInput))
                 ) : argsOrInput
               )
             ];
@@ -9818,16 +9858,16 @@ var tag_default = {
       const { node } = tag;
       const { name: name2, attributes } = tag.node;
       let crawl = false;
-      if (import_compiler58.types.isStringLiteral(name2)) {
+      if (import_compiler59.types.isStringLiteral(name2)) {
         const tagName = name2.value;
         if (tag.scope.getBinding(tagName) && TAG_NAME_IDENTIFIER_REG.test(tagName)) {
-          node.name = withPreviousLocation(import_compiler58.types.identifier(tagName), name2);
+          node.name = withPreviousLocation(import_compiler59.types.identifier(tagName), name2);
           crawl = true;
         }
       }
       for (let i = 0; i < attributes.length; i++) {
         const attr2 = attributes[i];
-        if (import_compiler58.types.isMarkoAttribute(attr2) && attr2.bound) {
+        if (import_compiler59.types.isMarkoAttribute(attr2) && attr2.bound) {
           attr2.bound = false;
           attributes.splice(++i, 0, getChangeHandler(tag, attr2));
           crawl = true;
@@ -9903,8 +9943,8 @@ var tag_default = {
       if (extra.tagNameDynamic && extra.tagNameNullable && !tag.get("name").isIdentifier() && isOutputHTML()) {
         const tagNameId = tag.scope.generateUidIdentifier("tagName");
         const [tagNameVarPath] = tag.insertBefore(
-          import_compiler58.types.variableDeclaration("const", [
-            import_compiler58.types.variableDeclarator(tagNameId, tag.node.name)
+          import_compiler59.types.variableDeclaration("const", [
+            import_compiler59.types.variableDeclarator(tagNameId, tag.node.name)
           ])
         );
         tagNameVarPath.skip();
@@ -9951,16 +9991,16 @@ var tag_default = {
 function getChangeHandler(tag, attr2) {
   const attrName = attr2.name;
   const changeAttrName = attrName + "Change";
-  if (import_compiler58.types.isIdentifier(attr2.value)) {
+  if (import_compiler59.types.isIdentifier(attr2.value)) {
     const binding = tag.scope.getBinding(attr2.value.name);
     if (!binding)
-      return import_compiler58.types.markoAttribute(
+      return import_compiler59.types.markoAttribute(
         changeAttrName,
         buildChangeHandlerFunction(attr2.value)
       );
     const existingChangedAttr = BINDING_CHANGE_HANDLER.get(binding.identifier);
     if (!existingChangedAttr) {
-      const changeHandlerAttr = import_compiler58.types.markoAttribute(
+      const changeHandlerAttr = import_compiler59.types.markoAttribute(
         changeAttrName,
         buildChangeHandlerFunction(attr2.value)
       );
@@ -9968,10 +10008,10 @@ function getChangeHandler(tag, attr2) {
       return changeHandlerAttr;
     }
     if (existingChangedAttr.type === "Identifier") {
-      return import_compiler58.types.markoAttribute(
+      return import_compiler59.types.markoAttribute(
         changeAttrName,
         withPreviousLocation(
-          import_compiler58.types.identifier(existingChangedAttr.name),
+          import_compiler59.types.identifier(existingChangedAttr.name),
           attr2.value
         )
       );
@@ -9981,37 +10021,37 @@ function getChangeHandler(tag, attr2) {
       throw tag.hub.buildError(attr2.value, "Unable to bind to value.");
     }
     const changeHandlerId = markoRoot.scope.generateUid(changeAttrName);
-    const changeHandlerConst = import_compiler58.types.markoTag(
-      import_compiler58.types.stringLiteral("const"),
-      [import_compiler58.types.markoAttribute("value", existingChangedAttr.value, null, null, true)],
-      import_compiler58.types.markoTagBody([]),
+    const changeHandlerConst = import_compiler59.types.markoTag(
+      import_compiler59.types.stringLiteral("const"),
+      [import_compiler59.types.markoAttribute("value", existingChangedAttr.value, null, null, true)],
+      import_compiler59.types.markoTagBody([]),
       null,
-      import_compiler58.types.identifier(changeHandlerId)
+      import_compiler59.types.identifier(changeHandlerId)
     );
     BINDING_CHANGE_HANDLER.set(
       binding.identifier,
-      existingChangedAttr.value = import_compiler58.types.identifier(changeHandlerId)
+      existingChangedAttr.value = import_compiler59.types.identifier(changeHandlerId)
     );
     if (markoRoot.isMarkoTag()) {
       markoRoot.insertAfter(changeHandlerConst);
     } else {
       markoRoot.unshiftContainer("body", changeHandlerConst);
     }
-    return import_compiler58.types.markoAttribute(
+    return import_compiler59.types.markoAttribute(
       changeAttrName,
-      withPreviousLocation(import_compiler58.types.identifier(changeHandlerId), attr2.value)
+      withPreviousLocation(import_compiler59.types.identifier(changeHandlerId), attr2.value)
     );
-  } else if (import_compiler58.types.isMemberExpression(attr2.value)) {
+  } else if (import_compiler59.types.isMemberExpression(attr2.value)) {
     const prop = attr2.value.property;
-    if (!import_compiler58.types.isPrivateName(attr2.value.property)) {
-      return import_compiler58.types.markoAttribute(
+    if (!import_compiler59.types.isPrivateName(attr2.value.property)) {
+      return import_compiler59.types.markoAttribute(
         changeAttrName,
-        import_compiler58.types.memberExpression(
-          import_compiler58.types.cloneNode(attr2.value.object),
-          prop.type === "Identifier" ? withPreviousLocation(import_compiler58.types.identifier(prop.name + "Change"), prop) : import_compiler58.types.binaryExpression(
+        import_compiler59.types.memberExpression(
+          import_compiler59.types.cloneNode(attr2.value.object),
+          prop.type === "Identifier" ? withPreviousLocation(import_compiler59.types.identifier(prop.name + "Change"), prop) : import_compiler59.types.binaryExpression(
             "+",
-            import_compiler58.types.cloneNode(prop),
-            import_compiler58.types.stringLiteral("Change")
+            import_compiler59.types.cloneNode(prop),
+            import_compiler59.types.stringLiteral("Change")
           ),
           prop.type !== "Identifier"
         )
@@ -10025,14 +10065,14 @@ function getChangeHandler(tag, attr2) {
 }
 function buildChangeHandlerFunction(id) {
   const newId = "_new_" + id.name;
-  return import_compiler58.types.arrowFunctionExpression(
-    [withPreviousLocation(import_compiler58.types.identifier(newId), id)],
-    import_compiler58.types.blockStatement([
-      import_compiler58.types.expressionStatement(
-        import_compiler58.types.assignmentExpression(
+  return import_compiler59.types.arrowFunctionExpression(
+    [withPreviousLocation(import_compiler59.types.identifier(newId), id)],
+    import_compiler59.types.blockStatement([
+      import_compiler59.types.expressionStatement(
+        import_compiler59.types.assignmentExpression(
           "=",
-          withPreviousLocation(import_compiler58.types.identifier(id.name), id),
-          withPreviousLocation(import_compiler58.types.identifier(newId), id)
+          withPreviousLocation(import_compiler59.types.identifier(id.name), id),
+          withPreviousLocation(import_compiler59.types.identifier(newId), id)
         )
       )
     ])
@@ -10040,10 +10080,11 @@ function buildChangeHandlerFunction(id) {
 }
 
 // src/translator/visitors/text.ts
-var import_compiler59 = require("@marko/compiler");
+var import_compiler60 = require("@marko/compiler");
 var text_default = {
   translate: {
     exit(text) {
+      if (isNonHTMLText(text)) return;
       writeTo(text)`${text.node.value}`;
       enterShallow(text);
       text.remove();