marko 6.0.115 → 6.0.117

package/dist/translator/index.js

@@ -1839,6 +1839,7 @@ function getNodeContentType(path5, extraMember, contentInfo) {
             return 0 /* Comment */;
           case "html-script":
           case "html-style":
+          case "title":
             return 3 /* Tag */;
           case "for":
           case "if":
@@ -1992,6 +1993,7 @@ function isNativeNode(tag) {
       case "html-comment":
       case "html-script":
       case "html-style":
+      case "title":
         return true;
       default:
         return false;
@@ -2237,21 +2239,50 @@ function bindingHasDownstreamExpressions(binding) {
 
 // src/translator/util/binding-prop-tree.ts
 function getBindingPropTree(binding) {
-  if (binding.type === 2 /* input */) {
-    binding.export ??= generateUid(binding.name);
-  }
   const props = {
     binding,
-    props: void 0
+    props: void 0,
+    rest: void 0
   };
-  if (!(binding.aliases.size || binding.downstreamExpressions.size)) {
-    props.props = {};
-    for (const [property, alias] of binding.propertyAliases) {
-      props.props[property] = getBindingPropTree(alias);
+  if (!binding.downstreamExpressions.size) {
+    if (!binding.aliases.size) {
+      props.props = {};
+      for (const [property, alias] of binding.propertyAliases) {
+        props.props[property] = getBindingPropTree(alias);
+      }
+    } else if (binding.aliases.size === 1) {
+      const [restAlias] = binding.aliases;
+      if (hasSupersetExcludeProperties(binding, restAlias.excludeProperties)) {
+        props.rest = getBindingPropTree(restAlias);
+        props.props = {};
+        if (restAlias.type === 2 /* input */) {
+          restAlias.export ??= generateUid(restAlias.name);
+        }
+        forEach(restAlias.excludeProperties, (property) => {
+          const propAlias = binding.propertyAliases.get(property);
+          if (propAlias) {
+            props.props[property] = getBindingPropTree(propAlias);
+          }
+        });
+      }
     }
   }
+  if (binding.type === 2 /* input */) {
+    binding.export ??= generateUid(binding.name);
+  }
   return props;
 }
+function hasSupersetExcludeProperties(binding, excludeProperties) {
+  if (excludeProperties === void 0) {
+    return false;
+  }
+  for (const prop of binding.propertyAliases.keys()) {
+    if (!propsUtil.has(excludeProperties, prop)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 // src/translator/util/entry-builder.ts
 var import_compiler9 = require("@marko/compiler");
@@ -5577,7 +5608,7 @@ var native_tag_default = {
               valueChange
             );
           } else if (value) {
-            writeAtStartOfBody = callRuntime("_escape_textarea_value", value);
+            writeAtStartOfBody = callRuntime("_to_text", value);
           }
         }
         for (const attr of staticAttrs) {
@@ -6582,14 +6613,15 @@ function getBaseArgsInForTag(type, attrs) {
 
 // src/translator/util/translate-attrs.ts
 var contentProps = /* @__PURE__ */ new WeakSet();
-function translateAttrs(tag, templateExports, statements = [], contentKey = "content") {
-  const seen = /* @__PURE__ */ new Set();
+function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "content") {
+  const templateExports = propTree && !propTree.rest ? propTree.props : void 0;
   const properties = [];
   const attrTagLookup = tag.node.extra?.attributeTags;
+  const seen = new Set(skip2);
   if (attrTagLookup) {
     for (const name2 in attrTagLookup) {
       const attrTagMeta = attrTagLookup[name2];
-      if (usesExport(templateExports, attrTagMeta.name)) {
+      if (!seen.has(name2) && usesExport(templateExports, attrTagMeta.name)) {
         seen.add(attrTagMeta.name);
         if (attrTagMeta.dynamic) {
           statements.push(
@@ -6624,7 +6656,8 @@ function translateAttrs(tag, templateExports, statements = [], contentKey = "con
           } else {
             const translatedAttrTag = translateAttrs(
               child,
-              templateExports?.[attrTagMeta.name]?.props,
+              templateExports?.[attrTagMeta.name],
+              void 0,
               statements,
               contentKey
             );
@@ -6713,7 +6746,8 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
       if (usesExport(templateExports, attrTagMeta.name) && attrTagMeta.dynamic) {
         const translatedAttrTag = translateAttrs(
           tag,
-          templateExports?.[attrTagMeta.name]?.props,
+          templateExports?.[attrTagMeta.name],
+          void 0,
           statements,
           contentKey
         );
@@ -7009,7 +7043,7 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
   const tagVar = node.var;
   const section = getSection(tag);
   const attrsPropTree = propTree?.props?.[tag.node.arguments?.length || 0];
-  const { properties, statements } = propTree && !propTree.props || attrsPropTree ? translateAttrs(tag, attrsPropTree?.props) : {
+  const { properties, statements } = propTree && !propTree.props || attrsPropTree ? translateAttrs(tag, attrsPropTree) : {
     properties: [],
     statements: []
   };
@@ -7267,6 +7301,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   const known = inputExpr.known = {};
   const attrTagLookup = analyzeAttributeTags(tag);
   const seen = /* @__PURE__ */ new Set();
+  const unknownReferences = [];
   if (attrTagLookup) {
     const nodeReferencesByGroup = /* @__PURE__ */ new Map();
     const analyzeDynamicChildGroup = (group, child) => {
@@ -7303,7 +7338,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
               analyzeDynamicChildGroup(attrTagMeta.group, child);
             }
           } else {
-            dropReferences(getAllTagReferenceNodes(child.node));
+            unknownReferences.push(getAllTagReferenceNodes(child.node));
           }
         } else {
           const group = child.node.extra.attributeTagGroup;
@@ -7317,7 +7352,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
           if (childUsesGroupProp) {
             analyzeDynamicChildGroup(group, child);
           } else {
-            dropReferences(getAllTagReferenceNodes(child.node));
+            unknownReferences.push(getAllTagReferenceNodes(child.node));
           }
         }
       }
@@ -7366,7 +7401,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     if (import_compiler34.types.isMarkoAttribute(attr)) {
       const templateExportAttr = propTree.props[attr.name];
       if (!templateExportAttr || seen.has(attr.name)) {
-        dropReferences(attr.value);
+        unknownReferences.push(attr.value);
         continue;
       }
       seen.add(attr.name);
@@ -7406,6 +7441,16 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     }
     setBindingDownstream(spreadBinding, extra);
   }
+  if (propTree.rest) {
+    const extra = inputExpr.value = mergeReferences(
+      section,
+      tag.node,
+      unknownReferences.flat()
+    );
+    setBindingDownstream(propTree.binding, extra);
+  } else {
+    unknownReferences.forEach(dropReferences);
+  }
   return inputExpr;
 }
 function writeParamsToSignals(tag, propTree, importAlias, info) {
@@ -7477,13 +7522,231 @@ function writeParamsToSignals(tag, propTree, importAlias, info) {
   }
 }
 function writeAttrsToSignals(tag, propTree, importAlias, info) {
-  if (!propTree.props) {
+  let translatedAttrs;
+  let seen;
+  let spreadId;
+  if (propTree.props) {
+    const attrTagLookup = analyzeAttributeTags(tag);
+    seen = /* @__PURE__ */ new Set();
+    if (attrTagLookup) {
+      const attrTags2 = tag.get("attributeTags");
+      const statementsByGroup = /* @__PURE__ */ new Map();
+      const translateDynamicAttrTagChildInGroup = (group, index) => {
+        const child = attrTags2[index];
+        let statements = statementsByGroup.get(group)?.statements;
+        if (!statements) {
+          statements = [];
+          statementsByGroup.set(group, {
+            referencedBindings: child.node.extra?.referencedBindings,
+            statements
+          });
+        }
+        return addDynamicAttrTagStatements(
+          attrTags2,
+          index,
+          attrTagLookup,
+          statements,
+          propTree.props
+        );
+      };
+      for (const attrTagName in attrTagLookup) {
+        seen.add(attrTagLookup[attrTagName].name);
+      }
+      for (let i = 0; i < attrTags2.length; i++) {
+        const child = attrTags2[i];
+        if (child.isMarkoTag()) {
+          if ((0, import_babel_utils24.isAttributeTag)(child)) {
+            const attrTagMeta = attrTagLookup[getTagName(child)];
+            const childAttrExport = propTree.props[attrTagMeta.name];
+            if (childAttrExport) {
+              if (attrTagMeta.dynamic) {
+                i = translateDynamicAttrTagChildInGroup(attrTagMeta.group, i);
+              } else {
+                writeAttrsToSignals(
+                  child,
+                  childAttrExport,
+                  `${importAlias}_${attrTagMeta.name}`,
+                  info
+                );
+              }
+            }
+          } else if (child.node.extra?.attributeTagGroup) {
+            i = translateDynamicAttrTagChildInGroup(
+              child.node.extra.attributeTagGroup,
+              i
+            );
+          }
+        }
+      }
+      for (const [
+        group,
+        { referencedBindings, statements }
+      ] of statementsByGroup) {
+        const decls = [];
+        for (const name2 of group) {
+          const attrTagMeta = attrTagLookup[name2];
+          const childAttrExports = propTree.props[attrTagMeta.name];
+          if (!childAttrExports) continue;
+          const attrExportIdentifier = info.getBindingIdentifier(
+            childAttrExports.binding,
+            `${importAlias}_${attrTagMeta.name}`
+          );
+          decls.push(import_compiler34.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
+          addStatement("render", info.tagSection, referencedBindings, [
+            import_compiler34.types.variableDeclaration("let", decls),
+            ...statements
+          ]);
+          addStatement(
+            "render",
+            info.tagSection,
+            referencedBindings,
+            import_compiler34.types.expressionStatement(
+              import_compiler34.types.callExpression(attrExportIdentifier, [
+                createScopeReadExpression(
+                  info.childScopeBinding,
+                  info.tagSection
+                ),
+                getAttrTagIdentifier(attrTagMeta)
+              ])
+            )
+          );
+        }
+      }
+    }
+    const bodySection = tag.node.body.extra?.section;
+    if (bodySection && !seen.has("content")) {
+      seen.add("content");
+      if (propTree.props.content) {
+        const contentExportIdentifier = info.getBindingIdentifier(
+          propTree.props.content.binding,
+          `${importAlias}_content`
+        );
+        addStatement(
+          "render",
+          info.tagSection,
+          void 0,
+          // TODO: pretty sure content needs to have the reference group of it's param defaults.
+          import_compiler34.types.expressionStatement(
+            import_compiler34.types.callExpression(contentExportIdentifier, [
+              createScopeReadExpression(
+                info.childScopeBinding,
+                info.tagSection
+              ),
+              import_compiler34.types.callExpression(import_compiler34.types.identifier(bodySection.name), [
+                scopeIdentifier
+              ])
+            ])
+          )
+        );
+      }
+    }
+    const { attributes } = tag.node;
+    const staticAttrs = [];
+    let spreadProps;
+    for (let i = attributes.length; i--; ) {
+      const attr = attributes[i];
+      if (import_compiler34.types.isMarkoAttribute(attr)) {
+        const childAttrExports = propTree.props[attr.name];
+        if (!childAttrExports || seen.has(attr.name)) continue;
+        if (spreadProps) {
+          spreadProps.push(toObjectProperty(attr.name, attr.value));
+          continue;
+        }
+        seen.add(attr.name);
+        staticAttrs.push(attr);
+      } else if (spreadProps) {
+        spreadProps.push(import_compiler34.types.spreadElement(attr.value));
+      } else {
+        spreadProps = [import_compiler34.types.spreadElement(attr.value)];
+      }
+    }
+    for (const attr of staticAttrs.reverse()) {
+      const childAttrExports = propTree.props[attr.name];
+      const attrExportIdentifier = info.getBindingIdentifier(
+        childAttrExports.binding,
+        `${importAlias}_${attr.name}`
+      );
+      addStatement(
+        "render",
+        info.tagSection,
+        attr.value.extra?.referencedBindings,
+        import_compiler34.types.expressionStatement(
+          import_compiler34.types.callExpression(attrExportIdentifier, [
+            createScopeReadExpression(info.childScopeBinding, info.tagSection),
+            attr.value
+          ])
+        )
+      );
+    }
+    const missing = new Set(Object.keys(propTree.props));
+    for (const name2 of seen) missing.delete(name2);
+    if (missing.size) {
+      const referencedBindings = tag.node.extra?.referencedBindings;
+      if (spreadProps) {
+        const spreadExpr = propsToExpression(
+          propTree.rest ? (translatedAttrs = translateAttrs(tag, propTree, seen)).properties : spreadProps.reverse()
+        );
+        if (isSimpleReference(spreadExpr)) {
+          spreadId = spreadExpr;
+        } else {
+          spreadId = generateUidIdentifier(`${importAlias}_spread`);
+          if (translatedAttrs) {
+            translatedAttrs.properties = [import_compiler34.types.spreadElement(spreadId)];
+          }
+          addStatement("render", info.tagSection, referencedBindings, [
+            import_compiler34.types.variableDeclaration("const", [
+              import_compiler34.types.variableDeclarator(spreadId, spreadExpr)
+            ])
+          ]);
+        }
+      }
+      for (const name2 of missing) {
+        const childAttrExports = propTree.props[name2];
+        const attrExportIdentifier = info.getBindingIdentifier(
+          childAttrExports.binding,
+          `${importAlias}_${name2}`
+        );
+        addStatement(
+          "render",
+          info.tagSection,
+          referencedBindings,
+          import_compiler34.types.expressionStatement(
+            import_compiler34.types.callExpression(
+              attrExportIdentifier,
+              spreadId ? [
+                createScopeReadExpression(
+                  info.childScopeBinding,
+                  info.tagSection
+                ),
+                toMemberExpression(import_compiler34.types.cloneNode(spreadId, true), name2)
+              ] : [
+                createScopeReadExpression(
+                  info.childScopeBinding,
+                  info.tagSection
+                )
+              ]
+            )
+          )
+        );
+      }
+    }
+  }
+  if (!propTree.props || propTree.rest) {
+    if (!translatedAttrs) {
+      if (propTree.rest) {
+        seen ||= /* @__PURE__ */ new Set();
+        forEach(
+          propTree.rest.binding.excludeProperties,
+          (prop) => seen.add(prop)
+        );
+      }
+      translatedAttrs = translateAttrs(tag, propTree.rest, seen);
+    }
     const referencedBindings = tag.node.extra?.referencedBindings;
     const tagInputIdentifier = info.getBindingIdentifier(
-      propTree.binding,
-      importAlias
+      propTree.rest?.binding || propTree.binding,
+      propTree.rest ? importAlias + "_$rest" : importAlias
     );
-    const translatedAttrs = translateAttrs(tag);
     if (translatedAttrs.statements.length) {
       addStatement(
         "render",
@@ -7493,6 +7756,27 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
       );
     }
     let translatedProps = propsToExpression(translatedAttrs.properties);
+    if (propTree.rest && spreadId) {
+      const props = [];
+      const restId = import_compiler34.types.identifier(propTree.rest.binding.name);
+      forEach(propTree.rest.binding.excludeProperties, (name2) => {
+        const propId = toPropertyName(name2);
+        const shorthand = propId.type === "Identifier" && import_compiler34.types.isValidIdentifier(name2);
+        props.push(
+          import_compiler34.types.objectProperty(
+            propId,
+            shorthand ? propId : generateUidIdentifier(name2),
+            false,
+            shorthand
+          )
+        );
+      });
+      props.push(import_compiler34.types.restElement(restId));
+      translatedProps = import_compiler34.types.callExpression(
+        import_compiler34.types.arrowFunctionExpression([import_compiler34.types.objectPattern(props)], restId),
+        [spreadId]
+      );
+    }
     if ((0, import_babel_utils24.isAttributeTag)(tag)) {
       const attrTagName = getTagName(tag);
       const parentTag = tag.parentPath;
@@ -7538,188 +7822,6 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         ])
       )
     );
-    return;
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const attrTagLookup = analyzeAttributeTags(tag);
-  if (attrTagLookup) {
-    const attrTags2 = tag.get("attributeTags");
-    const statementsByGroup = /* @__PURE__ */ new Map();
-    const translateDynamicAttrTagChildInGroup = (group, index) => {
-      const child = attrTags2[index];
-      let statements = statementsByGroup.get(group)?.statements;
-      if (!statements) {
-        statements = [];
-        statementsByGroup.set(group, {
-          referencedBindings: child.node.extra?.referencedBindings,
-          statements
-        });
-      }
-      return addDynamicAttrTagStatements(
-        attrTags2,
-        index,
-        attrTagLookup,
-        statements,
-        propTree.props
-      );
-    };
-    for (const attrTagName in attrTagLookup) {
-      seen.add(attrTagLookup[attrTagName].name);
-    }
-    for (let i = 0; i < attrTags2.length; i++) {
-      const child = attrTags2[i];
-      if (child.isMarkoTag()) {
-        if ((0, import_babel_utils24.isAttributeTag)(child)) {
-          const attrTagMeta = attrTagLookup[getTagName(child)];
-          const childAttrExport = propTree.props[attrTagMeta.name];
-          if (childAttrExport) {
-            if (attrTagMeta.dynamic) {
-              i = translateDynamicAttrTagChildInGroup(attrTagMeta.group, i);
-            } else {
-              writeAttrsToSignals(
-                child,
-                childAttrExport,
-                `${importAlias}_${attrTagMeta.name}`,
-                info
-              );
-            }
-          }
-        } else if (child.node.extra?.attributeTagGroup) {
-          i = translateDynamicAttrTagChildInGroup(
-            child.node.extra.attributeTagGroup,
-            i
-          );
-        }
-      }
-    }
-    for (const [
-      group,
-      { referencedBindings, statements }
-    ] of statementsByGroup) {
-      const decls = [];
-      for (const name2 of group) {
-        const attrTagMeta = attrTagLookup[name2];
-        const childAttrExports = propTree.props[attrTagMeta.name];
-        if (!childAttrExports) continue;
-        const attrExportIdentifier = info.getBindingIdentifier(
-          childAttrExports.binding,
-          `${importAlias}_${attrTagMeta.name}`
-        );
-        decls.push(import_compiler34.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
-        addStatement("render", info.tagSection, referencedBindings, [
-          import_compiler34.types.variableDeclaration("let", decls),
-          ...statements
-        ]);
-        addStatement(
-          "render",
-          info.tagSection,
-          referencedBindings,
-          import_compiler34.types.expressionStatement(
-            import_compiler34.types.callExpression(attrExportIdentifier, [
-              createScopeReadExpression(
-                info.childScopeBinding,
-                info.tagSection
-              ),
-              getAttrTagIdentifier(attrTagMeta)
-            ])
-          )
-        );
-      }
-    }
-  }
-  const bodySection = tag.node.body.extra?.section;
-  if (bodySection && !seen.has("content")) {
-    seen.add("content");
-    if (propTree.props.content) {
-      const contentExportIdentifier = info.getBindingIdentifier(
-        propTree.props.content.binding,
-        `${importAlias}_content`
-      );
-      addStatement(
-        "render",
-        info.tagSection,
-        void 0,
-        // TODO: pretty sure content needs to have the reference group of it's param defaults.
-        import_compiler34.types.expressionStatement(
-          import_compiler34.types.callExpression(contentExportIdentifier, [
-            createScopeReadExpression(info.childScopeBinding, info.tagSection),
-            import_compiler34.types.callExpression(import_compiler34.types.identifier(bodySection.name), [scopeIdentifier])
-          ])
-        )
-      );
-    }
-  }
-  const { attributes } = tag.node;
-  const staticAttrs = [];
-  let spreadProps;
-  for (let i = attributes.length; i--; ) {
-    const attr = attributes[i];
-    if (import_compiler34.types.isMarkoAttribute(attr)) {
-      const childAttrExports = propTree.props[attr.name];
-      if (!childAttrExports || seen.has(attr.name)) continue;
-      seen.add(attr.name);
-      if (spreadProps) {
-        spreadProps.push(toObjectProperty(attr.name, attr.value));
-        continue;
-      }
-      staticAttrs.push(attr);
-    } else if (spreadProps) {
-      spreadProps.push(import_compiler34.types.spreadElement(attr.value));
-    } else {
-      spreadProps = [import_compiler34.types.spreadElement(attr.value)];
-    }
-  }
-  for (const attr of staticAttrs.reverse()) {
-    const childAttrExports = propTree.props[attr.name];
-    const attrExportIdentifier = info.getBindingIdentifier(
-      childAttrExports.binding,
-      `${importAlias}_${attr.name}`
-    );
-    addStatement(
-      "render",
-      info.tagSection,
-      attr.value.extra?.referencedBindings,
-      import_compiler34.types.expressionStatement(
-        import_compiler34.types.callExpression(attrExportIdentifier, [
-          createScopeReadExpression(info.childScopeBinding, info.tagSection),
-          attr.value
-        ])
-      )
-    );
-  }
-  const missing = new Set(Object.keys(propTree.props));
-  for (const name2 of seen) missing.delete(name2);
-  if (missing.size) {
-    const referencedBindings = tag.node.extra?.referencedBindings;
-    let getMissingPropValue = buildUndefined3;
-    if (spreadProps) {
-      const spreadId = generateUidIdentifier(`${importAlias}_spread`);
-      spreadProps.reverse();
-      getMissingPropValue = (name2) => toMemberExpression(spreadId, name2);
-      addStatement("render", info.tagSection, referencedBindings, [
-        import_compiler34.types.variableDeclaration("const", [
-          import_compiler34.types.variableDeclarator(spreadId, propsToExpression(spreadProps))
-        ])
-      ]);
-    }
-    for (const name2 of missing) {
-      const childAttrExports = propTree.props[name2];
-      const attrExportIdentifier = info.getBindingIdentifier(
-        childAttrExports.binding,
-        `${importAlias}_${name2}`
-      );
-      addStatement(
-        "render",
-        info.tagSection,
-        referencedBindings,
-        import_compiler34.types.expressionStatement(
-          import_compiler34.types.callExpression(attrExportIdentifier, [
-            createScopeReadExpression(info.childScopeBinding, info.tagSection),
-            getMissingPropValue(name2)
-          ])
-        )
-      );
-    }
   }
 }
 function mapParamReasonToExpr(exprs, reason) {
@@ -7754,8 +7856,15 @@ function callStatement(id, ...args) {
 function callExpression(id, ...args) {
   return import_compiler34.types.callExpression(id, args.filter(Boolean));
 }
-function buildUndefined3() {
-  return import_compiler34.types.unaryExpression("void", import_compiler34.types.numericLiteral(0));
+function isSimpleReference(expr) {
+  switch (expr.type) {
+    case "Identifier":
+      return true;
+    case "MemberExpression":
+      return !expr.computed && isSimpleReference(expr.object);
+    default:
+      return false;
+  }
 }
 
 // src/translator/util/references.ts
@@ -9614,7 +9723,7 @@ function bodyToTextLiteral(body) {
     } else if (import_compiler42.types.isMarkoPlaceholder(child)) {
       placeholderExtra ||= child.value.extra;
       templateQuasis.push(templateElement(currentQuasi, false));
-      templateExpressions.push(child.value);
+      templateExpressions.push(callRuntime("_to_text", child.value));
       currentQuasi = "";
     }
   }
@@ -9700,7 +9809,7 @@ var html_comment_default = {
           if (import_compiler43.types.isMarkoText(child)) {
             write`${child.value}`;
           } else if (import_compiler43.types.isMarkoPlaceholder(child)) {
-            write`${callRuntime("_escape", child.value)}`;
+            write`${callRuntime("_to_text", child.value)}`;
           }
         }
       } else {
@@ -11520,7 +11629,7 @@ var textarea_default = {
       tag.node.attributes.push(
         import_compiler56.types.markoAttribute(
           "value",
-          normalizeStringExpression(parts) || buildUndefined4()
+          normalizeStringExpression(parts) || buildUndefined3()
         )
       );
       tag.node.body.body = [];
@@ -11531,28 +11640,352 @@ var textarea_default = {
     preserveWhitespace: true
   }
 };
-function buildUndefined4() {
+function buildUndefined3() {
   return import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0));
 }
 
-// src/translator/core/try.ts
+// src/translator/core/title.ts
 var import_compiler57 = require("@marko/compiler");
 var import_babel_utils46 = require("@marko/compiler/babel-utils");
-var hasEnabledCatch = /* @__PURE__ */ new WeakSet();
-var kDOMBinding2 = Symbol("try tag dom binding");
-var try_default = {
+var kNodeBinding4 = Symbol("title tag node binding");
+var title_default = {
   analyze(tag) {
-    (0, import_babel_utils46.assertNoVar)(tag);
     (0, import_babel_utils46.assertNoArgs)(tag);
     (0, import_babel_utils46.assertNoParams)(tag);
-    (0, import_babel_utils46.assertNoAttributes)(tag);
-    assertNoSpreadAttrs(tag);
-    analyzeAttributeTags(tag);
-    const section = getOrCreateSection(tag);
-    const tagExtra = mergeReferences(
-      section,
-      tag.node,
-      getAllTagReferenceNodes(tag.node)
+    const { node } = tag;
+    if (node.var && !import_compiler57.types.isIdentifier(node.var)) {
+      throw tag.get("var").buildCodeFrameError(
+        "Tag variables on native elements cannot be destructured."
+      );
+    }
+    const seen = {};
+    const { attributes } = tag.node;
+    let spreadReferenceNodes;
+    let exprExtras;
+    let hasEventHandlers = false;
+    let hasDynamicAttributes = false;
+    for (let i = attributes.length; i--; ) {
+      const attr = attributes[i];
+      const valueExtra = attr.value.extra ??= {};
+      if (import_compiler57.types.isMarkoAttribute(attr)) {
+        if (seen[attr.name]) {
+          dropReferences(attr.value);
+          continue;
+        }
+        seen[attr.name] = attr;
+        if (isEventHandler(attr.name)) {
+          valueExtra.isEffect = true;
+          hasEventHandlers = true;
+        } else if (!evaluate(attr.value).confident) {
+          hasDynamicAttributes = true;
+        }
+      } else if (import_compiler57.types.isMarkoSpreadAttribute(attr)) {
+        valueExtra.isEffect = true;
+        hasEventHandlers = true;
+        hasDynamicAttributes = true;
+      }
+      if (spreadReferenceNodes) {
+        spreadReferenceNodes.push(attr.value);
+      } else if (import_compiler57.types.isMarkoSpreadAttribute(attr)) {
+        spreadReferenceNodes = [attr.value];
+      } else {
+        exprExtras = push(exprExtras, valueExtra);
+      }
+    }
+    const bodyPlaceholderNodes = [];
+    let hasBodyPlaceholders = false;
+    for (const child of tag.node.body.body) {
+      if (import_compiler57.types.isMarkoPlaceholder(child)) {
+        bodyPlaceholderNodes.push(child.value);
+        hasBodyPlaceholders = true;
+      } else if (!import_compiler57.types.isMarkoText(child)) {
+        throw tag.hub.buildError(
+          child,
+          "Invalid child. Only text is allowed inside a `<title>`."
+        );
+      }
+    }
+    if (node.var || hasEventHandlers || hasDynamicAttributes || hasBodyPlaceholders) {
+      const tagExtra = node.extra ??= {};
+      const tagSection = getOrCreateSection(tag);
+      const nodeBinding = tagExtra[kNodeBinding4] = createBinding(
+        "#title",
+        0 /* dom */,
+        tagSection
+      );
+      if (hasEventHandlers) {
+        (0, import_babel_utils46.getProgram)().node.extra.isInteractive = true;
+      }
+      if (spreadReferenceNodes) {
+        mergeReferences(tagSection, tag.node, spreadReferenceNodes);
+      }
+      if (hasBodyPlaceholders) {
+        exprExtras = push(
+          exprExtras,
+          bodyPlaceholderNodes.length === 1 ? bodyPlaceholderNodes[0].extra ??= {} : mergeReferences(
+            tagSection,
+            bodyPlaceholderNodes[0],
+            bodyPlaceholderNodes.slice(1)
+          )
+        );
+      }
+      trackDomVarReferences(tag, nodeBinding);
+      addSerializeExpr(
+        tagSection,
+        !!(node.var || hasEventHandlers),
+        nodeBinding
+      );
+      addSerializeExpr(tagSection, push(exprExtras, tagExtra), nodeBinding);
+    }
+  },
+  translate: {
+    enter(tag) {
+      const tagExtra = tag.node.extra;
+      const nodeBinding = tagExtra[kNodeBinding4];
+      const isHTML = isOutputHTML();
+      const write = writeTo(tag);
+      const tagSection = getSection(tag);
+      if (isHTML) {
+        translateDomVar(tag, nodeBinding);
+      }
+      if (nodeBinding) {
+        visit(tag, 32 /* Get */);
+      }
+      write`<title`;
+      const usedAttrs = getUsedAttrs4(tag.node);
+      const { staticAttrs, skipExpression, spreadExpression } = usedAttrs;
+      for (const attr of staticAttrs) {
+        const { name: name2, value } = attr;
+        const { confident, computed } = value.extra || {};
+        const valueReferences = value.extra?.referencedBindings;
+        switch (name2) {
+          case "class":
+          case "style": {
+            const helper = `_attr_${name2}`;
+            if (confident) {
+              write`${getHTMLRuntime()[helper](computed)}`;
+            } else if (isHTML) {
+              write`${callRuntime(helper, value)}`;
+            } else {
+              addStatement(
+                "render",
+                tagSection,
+                valueReferences,
+                import_compiler57.types.expressionStatement(
+                  callRuntime(
+                    helper,
+                    createScopeReadExpression(nodeBinding),
+                    value
+                  )
+                )
+              );
+            }
+            break;
+          }
+          default:
+            if (confident) {
+              write`${getHTMLRuntime()._attr(name2, computed)}`;
+            } else if (isHTML) {
+              if (isEventHandler(name2)) {
+                addHTMLEffectCall(tagSection, valueReferences);
+              } else {
+                write`${callRuntime("_attr", import_compiler57.types.stringLiteral(name2), value)}`;
+              }
+            } else if (isEventHandler(name2)) {
+              addStatement(
+                "effect",
+                tagSection,
+                valueReferences,
+                import_compiler57.types.expressionStatement(
+                  callRuntime(
+                    "_on",
+                    createScopeReadExpression(nodeBinding),
+                    import_compiler57.types.stringLiteral(getEventHandlerName(name2)),
+                    value
+                  )
+                )
+              );
+            } else {
+              addStatement(
+                "render",
+                tagSection,
+                valueReferences,
+                import_compiler57.types.expressionStatement(
+                  callRuntime(
+                    "_attr",
+                    createScopeReadExpression(nodeBinding),
+                    import_compiler57.types.stringLiteral(name2),
+                    value
+                  )
+                )
+              );
+            }
+            break;
+        }
+      }
+      if (spreadExpression) {
+        const visitAccessor = getScopeAccessorLiteral(nodeBinding);
+        if (isHTML) {
+          addHTMLEffectCall(tagSection, tagExtra.referencedBindings);
+          if (skipExpression) {
+            write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler57.types.stringLiteral("title"))}`;
+          } else {
+            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler57.types.stringLiteral("title"))}`;
+          }
+        } else {
+          if (skipExpression) {
+            addStatement(
+              "render",
+              tagSection,
+              tagExtra.referencedBindings,
+              import_compiler57.types.expressionStatement(
+                callRuntime(
+                  "_attrs_partial",
+                  scopeIdentifier,
+                  visitAccessor,
+                  spreadExpression,
+                  skipExpression
+                )
+              )
+            );
+          } else {
+            addStatement(
+              "render",
+              tagSection,
+              tagExtra.referencedBindings,
+              import_compiler57.types.expressionStatement(
+                callRuntime(
+                  "_attrs",
+                  scopeIdentifier,
+                  visitAccessor,
+                  spreadExpression
+                )
+              )
+            );
+          }
+          addStatement(
+            "effect",
+            tagSection,
+            tagExtra.referencedBindings,
+            import_compiler57.types.expressionStatement(
+              callRuntime("_attrs_script", scopeIdentifier, visitAccessor)
+            ),
+            false
+          );
+        }
+      }
+      write`>`;
+      enter2(tag);
+    },
+    exit(tag) {
+      const tagSection = getSection(tag);
+      const tagExtra = tag.node.extra;
+      const nodeBinding = tagExtra[kNodeBinding4];
+      const write = writeTo(tag);
+      if (isOutputHTML()) {
+        for (const child of tag.node.body.body) {
+          if (import_compiler57.types.isMarkoText(child)) {
+            write`${child.value}`;
+          } else if (import_compiler57.types.isMarkoPlaceholder(child)) {
+            write`${callRuntime("_to_text", child.value)}`;
+          }
+        }
+      } else {
+        const textLiteral = bodyToTextLiteral(tag.node.body);
+        if (import_compiler57.types.isStringLiteral(textLiteral)) {
+          write`${textLiteral}`;
+        } else {
+          addStatement(
+            "render",
+            getSection(tag),
+            textLiteral.extra?.referencedBindings,
+            import_compiler57.types.expressionStatement(
+              callRuntime(
+                "_text_content",
+                createScopeReadExpression(nodeBinding),
+                textLiteral
+              )
+            )
+          );
+        }
+      }
+      write`</title>`;
+      if (nodeBinding) {
+        markNode(
+          tag,
+          nodeBinding,
+          getSerializeReason(tagSection, nodeBinding)
+        );
+      }
+      exit2(tag);
+      tag.remove();
+    }
+  },
+  parseOptions: {
+    text: true
+  }
+};
+function getUsedAttrs4(tag) {
+  const seen = {};
+  const { attributes } = tag;
+  const maybeStaticAttrs = /* @__PURE__ */ new Set();
+  let spreadExpression;
+  let skipExpression;
+  let spreadProps;
+  let skipProps;
+  for (let i = attributes.length; i--; ) {
+    const attr = attributes[i];
+    const { value } = attr;
+    if (import_compiler57.types.isMarkoSpreadAttribute(attr)) {
+      if (!spreadProps) {
+        spreadProps = [];
+      }
+      spreadProps.push(import_compiler57.types.spreadElement(value));
+    } else if (!seen[attr.name]) {
+      seen[attr.name] = attr;
+      if (spreadProps) {
+        spreadProps.push(toObjectProperty(attr.name, attr.value));
+      } else {
+        maybeStaticAttrs.add(attr);
+      }
+    }
+  }
+  const staticAttrs = [...maybeStaticAttrs].reverse();
+  if (spreadProps) {
+    spreadProps.reverse();
+    for (const { name: name2 } of staticAttrs) {
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler57.types.numericLiteral(1)));
+    }
+    if (skipProps) {
+      skipExpression = import_compiler57.types.objectExpression(skipProps);
+    }
+    spreadExpression = propsToExpression(spreadProps);
+  }
+  return {
+    staticAttrs,
+    spreadExpression,
+    skipExpression
+  };
+}
+
+// src/translator/core/try.ts
+var import_compiler58 = require("@marko/compiler");
+var import_babel_utils47 = require("@marko/compiler/babel-utils");
+var hasEnabledCatch = /* @__PURE__ */ new WeakSet();
+var kDOMBinding2 = Symbol("try tag dom binding");
+var try_default = {
+  analyze(tag) {
+    (0, import_babel_utils47.assertNoVar)(tag);
+    (0, import_babel_utils47.assertNoArgs)(tag);
+    (0, import_babel_utils47.assertNoParams)(tag);
+    (0, import_babel_utils47.assertNoAttributes)(tag);
+    assertNoSpreadAttrs(tag);
+    analyzeAttributeTags(tag);
+    const section = getOrCreateSection(tag);
+    const tagExtra = mergeReferences(
+      section,
+      tag.node,
+      getAllTagReferenceNodes(tag.node)
     );
     tagExtra[kDOMBinding2] = createBinding("#text", 0 /* dom */, section);
     if (!tag.node.body.body.length) {
@@ -11597,7 +12030,7 @@ var try_default = {
         writeHTMLResumeStatements(tagBody);
         tag.insertBefore(translatedAttrs.statements);
         tag.replaceWith(
-          import_compiler57.types.expressionStatement(
+          import_compiler58.types.expressionStatement(
             callRuntime(
               "_try",
               getScopeIdIdentifier(section),
@@ -11652,11 +12085,11 @@ var try_default = {
             translatedAttrs.statements
           );
         }
-        const program = (0, import_babel_utils46.getProgram)().node;
+        const program = (0, import_babel_utils47.getProgram)().node;
         if (!hasEnabledCatch.has(program)) {
           hasEnabledCatch.add(program);
           program.body.push(
-            import_compiler57.types.expressionStatement(callRuntime("_enable_catch"))
+            import_compiler58.types.expressionStatement(callRuntime("_enable_catch"))
           );
         }
         addValue(
@@ -11708,6 +12141,7 @@ var core_default = {
   "<static>": static_default,
   "<style>": style_default,
   "<textarea>": textarea_default,
+  "<title>": title_default,
   "<try>": try_default
 };
 
@@ -11755,13 +12189,13 @@ var document_type_default = {
 };
 
 // src/translator/visitors/import-declaration.ts
-var import_babel_utils47 = require("@marko/compiler/babel-utils");
+var import_babel_utils48 = require("@marko/compiler/babel-utils");
 var import_declaration_default = {
   analyze(importDecl) {
     const { node } = importDecl;
     const { source } = node;
     const { value } = source;
-    const tagImport = (0, import_babel_utils47.resolveTagImport)(importDecl, value);
+    const tagImport = (0, import_babel_utils48.resolveTagImport)(importDecl, value);
     if (tagImport) {
       node.extra ??= {};
       node.extra.tagImport = tagImport;
@@ -11784,10 +12218,10 @@ var import_declaration_default = {
 };
 
 // src/translator/visitors/placeholder.ts
-var import_compiler59 = require("@marko/compiler");
+var import_compiler60 = require("@marko/compiler");
 
 // src/translator/util/is-non-html-text.ts
-var import_compiler58 = require("@marko/compiler");
+var import_compiler59 = require("@marko/compiler");
 function isNonHTMLText(placeholder) {
   const parentTag = placeholder.parentPath.isMarkoTagBody() && placeholder.parentPath.parentPath;
   if (parentTag && isCoreTag(parentTag)) {
@@ -11795,6 +12229,7 @@ function isNonHTMLText(placeholder) {
       case "html-comment":
       case "html-script":
       case "html-style":
+      case "title":
         return true;
     }
   }
@@ -11802,7 +12237,7 @@ function isNonHTMLText(placeholder) {
 }
 
 // src/translator/visitors/placeholder.ts
-var kNodeBinding4 = Symbol("placeholder node binding");
+var kNodeBinding5 = Symbol("placeholder node binding");
 var kSiblingText = Symbol("placeholder has sibling text");
 var kSharedText = Symbol(
   "placeholder will merge its visitor with a another node"
@@ -11820,7 +12255,7 @@ var placeholder_default = {
       }
     } else {
       const section = getOrCreateSection(placeholder);
-      const nodeBinding = (node.extra ??= {})[kNodeBinding4] = createBinding(
+      const nodeBinding = (node.extra ??= {})[kNodeBinding5] = createBinding(
         "#text",
         0 /* dom */,
         section
@@ -11843,7 +12278,7 @@ var placeholder_default = {
       const isHTML = isOutputHTML();
       const write = writeTo(placeholder);
       const extra = node.extra || {};
-      const nodeBinding = extra[kNodeBinding4];
+      const nodeBinding = extra[kNodeBinding5];
       const canWriteHTML = isHTML || confident && node.escape;
       const method = canWriteHTML ? node.escape ? "_escape" : "_unescaped" : node.escape ? "_text" : "_html";
       if (confident && canWriteHTML) {
@@ -11877,7 +12312,7 @@ var placeholder_default = {
             "render",
             getSection(placeholder),
             valueExtra.referencedBindings,
-            import_compiler59.types.expressionStatement(
+            import_compiler60.types.expressionStatement(
               method === "_text" ? callRuntime(
                 "_text",
                 createScopeReadExpression(nodeBinding),
@@ -11915,7 +12350,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!prev.node && import_compiler59.types.isProgram(placeholder.parentPath)) {
+  if (!prev.node && import_compiler60.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 1 /* Before */;
   }
   let next = placeholder.getNextSibling();
@@ -11932,7 +12367,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!next.node && import_compiler59.types.isProgram(placeholder.parentPath)) {
+  if (!next.node && import_compiler60.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 2 /* After */;
   }
   return placeholderExtra[kSiblingText] = 0 /* None */;
@@ -11974,7 +12409,7 @@ function isEmptyPlaceholder(placeholder) {
 }
 
 // src/translator/visitors/referenced-identifier.ts
-var import_compiler60 = require("@marko/compiler");
+var import_compiler61 = require("@marko/compiler");
 var abortIdsByExpressionForSection = /* @__PURE__ */ new WeakMap();
 var referenced_identifier_default = {
   migrate(identifier) {
@@ -11982,8 +12417,8 @@ var referenced_identifier_default = {
     if (identifier.scope.hasBinding(name2)) return;
     switch (name2) {
       case "out":
-        if (import_compiler60.types.isMemberExpression(identifier.parent) && import_compiler60.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
-          identifier.parentPath.replaceWith(import_compiler60.types.identifier("$global"));
+        if (import_compiler61.types.isMemberExpression(identifier.parent) && import_compiler61.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
+          identifier.parentPath.replaceWith(import_compiler61.types.identifier("$global"));
         } else {
           throw identifier.buildCodeFrameError(
             "Only `out.global` is supported for compatibility."
@@ -12010,13 +12445,13 @@ var referenced_identifier_default = {
       case "$global":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler60.types.callExpression(importRuntime("$global"), [])
+            import_compiler61.types.callExpression(importRuntime("$global"), [])
           );
         } else {
           identifier.replaceWith(
-            import_compiler60.types.memberExpression(
+            import_compiler61.types.memberExpression(
               scopeIdentifier,
-              import_compiler60.types.identifier(getAccessorProp().Global)
+              import_compiler61.types.identifier(getAccessorProp().Global)
             )
           );
         }
@@ -12024,13 +12459,13 @@ var referenced_identifier_default = {
       case "$signal":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler60.types.callExpression(
-              import_compiler60.types.arrowFunctionExpression(
+            import_compiler61.types.callExpression(
+              import_compiler61.types.arrowFunctionExpression(
                 [],
-                import_compiler60.types.blockStatement([
-                  import_compiler60.types.throwStatement(
-                    import_compiler60.types.newExpression(import_compiler60.types.identifier("Error"), [
-                      import_compiler60.types.stringLiteral("Cannot use $signal in a server render.")
+                import_compiler61.types.blockStatement([
+                  import_compiler61.types.throwStatement(
+                    import_compiler61.types.newExpression(import_compiler61.types.identifier("Error"), [
+                      import_compiler61.types.stringLiteral("Cannot use $signal in a server render.")
                     ])
                   )
                 ])
@@ -12056,19 +12491,19 @@ var referenced_identifier_default = {
               "render",
               section,
               exprRoot.node.extra?.referencedBindings,
-              import_compiler60.types.expressionStatement(
-                import_compiler60.types.callExpression(importRuntime("$signalReset"), [
+              import_compiler61.types.expressionStatement(
+                import_compiler61.types.callExpression(importRuntime("$signalReset"), [
                   scopeIdentifier,
-                  import_compiler60.types.numericLiteral(exprId)
+                  import_compiler61.types.numericLiteral(exprId)
                 ])
               ),
               false
             );
           }
           identifier.replaceWith(
-            import_compiler60.types.callExpression(importRuntime("$signal"), [
+            import_compiler61.types.callExpression(importRuntime("$signal"), [
               scopeIdentifier,
-              import_compiler60.types.numericLiteral(exprId)
+              import_compiler61.types.numericLiteral(exprId)
             ])
           );
         }
@@ -12077,7 +12512,7 @@ var referenced_identifier_default = {
 };
 
 // src/translator/visitors/scriptlet.ts
-var import_babel_utils48 = require("@marko/compiler/babel-utils");
+var import_babel_utils49 = require("@marko/compiler/babel-utils");
 var scriptlet_default = {
   analyze(scriptlet) {
     if (!scriptlet.node.static) {
@@ -12091,7 +12526,7 @@ var scriptlet_default = {
       scriptlet.node.body
     );
     if (scriptlet.node.target === "client") {
-      (0, import_babel_utils48.getProgram)().node.extra.isInteractive = true;
+      (0, import_babel_utils49.getProgram)().node.extra.isInteractive = true;
     }
   },
   translate: {
@@ -12112,21 +12547,21 @@ var scriptlet_default = {
 };
 
 // src/translator/visitors/tag/index.ts
-var import_compiler64 = require("@marko/compiler");
-var import_babel_utils52 = require("@marko/compiler/babel-utils");
+var import_compiler65 = require("@marko/compiler");
+var import_babel_utils53 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/attribute-tag.ts
-var import_compiler61 = require("@marko/compiler");
-var import_babel_utils49 = require("@marko/compiler/babel-utils");
+var import_compiler62 = require("@marko/compiler");
+var import_babel_utils50 = require("@marko/compiler/babel-utils");
 var attribute_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils49.assertNoVar)(tag);
-      (0, import_babel_utils49.assertNoArgs)(tag);
+      (0, import_babel_utils50.assertNoVar)(tag);
+      (0, import_babel_utils50.assertNoArgs)(tag);
       const body = tag.get("body");
       startSection(body);
       trackParamsReferences(body, 3 /* param */);
-      if (!(0, import_babel_utils49.findParentTag)(tag)) {
+      if (!(0, import_babel_utils50.findParentTag)(tag)) {
         throw tag.get("name").buildCodeFrameError(
           "[Attribute tags](https://markojs.com/docs/reference/language#attribute-tags) must be nested within another tag."
         );
@@ -12149,13 +12584,13 @@ var attribute_tag_default = {
 };
 
 // src/translator/visitors/tag/custom-tag.ts
-var import_compiler62 = require("@marko/compiler");
-var import_babel_utils50 = require("@marko/compiler/babel-utils");
+var import_compiler63 = require("@marko/compiler");
+var import_babel_utils51 = require("@marko/compiler/babel-utils");
 var import_path4 = __toESM(require("path"));
 var custom_tag_default = {
   analyze: {
     enter(tag) {
-      const templateFile = (0, import_babel_utils50.getTagTemplate)(tag);
+      const templateFile = (0, import_babel_utils51.getTagTemplate)(tag);
       if (!templateFile) {
         const tagName = getTagName(tag);
         if (tagName && tag.scope.hasBinding(tagName)) {
@@ -12167,12 +12602,12 @@ var custom_tag_default = {
           `Unable to find entry point for [custom tag](https://markojs.com/docs/reference/custom-tag#relative-custom-tags) \`<${tagName}>\`.`
         );
       }
-      (0, import_babel_utils50.assertAttributesOrSingleArg)(tag);
-      const childFile = (0, import_babel_utils50.loadFileForTag)(tag);
+      (0, import_babel_utils51.assertAttributesOrSingleArg)(tag);
+      const childFile = (0, import_babel_utils51.loadFileForTag)(tag);
       if (!childFile) {
         throw tag.get("name").buildCodeFrameError("Unable to resolve file for tag.");
       }
-      const programSection = (0, import_babel_utils50.getProgram)().node.extra.section;
+      const programSection = (0, import_babel_utils51.getProgram)().node.extra.section;
       const childProgram = childFile.ast.program;
       const childExtra = childProgram.extra;
       const childSection = childExtra.section;
@@ -12200,12 +12635,12 @@ var custom_tag_default = {
 };
 function translateHTML(tag) {
   const { node } = tag;
-  const childProgram = (0, import_babel_utils50.loadFileForTag)(tag).ast.program;
+  const childProgram = (0, import_babel_utils51.loadFileForTag)(tag).ast.program;
   const childExtra = childProgram.extra;
   let tagIdentifier;
-  if (import_compiler62.types.isStringLiteral(node.name)) {
+  if (import_compiler63.types.isStringLiteral(node.name)) {
     const relativePath = getTagRelativePath(tag);
-    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler62.types.identifier(getTemplateContentName()) : (0, import_babel_utils50.importDefault)(tag.hub.file, relativePath, getTagName(tag));
+    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler63.types.identifier(getTemplateContentName()) : (0, import_babel_utils51.importDefault)(tag.hub.file, relativePath, getTagName(tag));
   } else {
     tagIdentifier = node.name;
   }
@@ -12221,12 +12656,12 @@ function translateDOM(tag) {
   const { file } = tag.hub;
   const write = writeTo(tag);
   const relativePath = getTagRelativePath(tag);
-  const programSection = (0, import_babel_utils50.getProgram)().node.extra.section;
-  const childFile = (0, import_babel_utils50.loadFileForTag)(tag);
+  const programSection = (0, import_babel_utils51.getProgram)().node.extra.section;
+  const childFile = (0, import_babel_utils51.loadFileForTag)(tag);
   const childExtra = childFile.ast.program.extra;
   const childExports = childExtra.domExports;
   const childSection = childExtra.section;
-  const tagName = import_compiler62.types.isIdentifier(node.name) ? node.name.name : import_compiler62.types.isStringLiteral(node.name) ? node.name.value : "tag";
+  const tagName = import_compiler63.types.isIdentifier(node.name) ? node.name.name : import_compiler63.types.isStringLiteral(node.name) ? node.name.value : "tag";
   if (programSection === childSection) {
     knownTagTranslateDOM(
       tag,
@@ -12237,16 +12672,16 @@ function translateDOM(tag) {
           "render",
           section,
           void 0,
-          import_compiler62.types.expressionStatement(
-            import_compiler62.types.callExpression(import_compiler62.types.identifier(childExports.setup), [
+          import_compiler63.types.expressionStatement(
+            import_compiler63.types.callExpression(import_compiler63.types.identifier(childExports.setup), [
               createScopeReadExpression(childBinding, section)
             ])
           )
         );
       }
     );
-    write`${import_compiler62.types.identifier(childExports.template)}`;
-    injectWalks(tag, tagName, import_compiler62.types.identifier(childExports.walks));
+    write`${import_compiler63.types.identifier(childExports.template)}`;
+    injectWalks(tag, tagName, import_compiler63.types.identifier(childExports.walks));
   } else {
     knownTagTranslateDOM(
       tag,
@@ -12262,8 +12697,8 @@ function translateDOM(tag) {
           "render",
           section,
           void 0,
-          import_compiler62.types.expressionStatement(
-            import_compiler62.types.callExpression(
+          import_compiler63.types.expressionStatement(
+            import_compiler63.types.callExpression(
               importOrSelfReferenceName(
                 file,
                 relativePath,
@@ -12276,11 +12711,11 @@ function translateDOM(tag) {
         );
       }
     );
-    write`${(0, import_babel_utils50.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
+    write`${(0, import_babel_utils51.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
     injectWalks(
       tag,
       tagName,
-      (0, import_babel_utils50.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
+      (0, import_babel_utils51.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
     );
   }
   tag.remove();
@@ -12291,9 +12726,9 @@ function getTagRelativePath(tag) {
     hub: { file }
   } = tag;
   let relativePath;
-  if (import_compiler62.types.isStringLiteral(node.name)) {
-    const template = (0, import_babel_utils50.getTagTemplate)(tag);
-    relativePath = template && (0, import_babel_utils50.resolveRelativePath)(file, template);
+  if (import_compiler63.types.isStringLiteral(node.name)) {
+    const template = (0, import_babel_utils51.getTagTemplate)(tag);
+    relativePath = template && (0, import_babel_utils51.resolveRelativePath)(file, template);
   } else if (node.extra?.tagNameImported) {
     relativePath = node.extra.tagNameImported;
   }
@@ -12312,9 +12747,9 @@ function getTagRelativePath(tag) {
 }
 function importOrSelfReferenceName(file, request, name2, nameHint) {
   if (isCircularRequest(file, request)) {
-    return import_compiler62.types.identifier(name2);
+    return import_compiler63.types.identifier(name2);
   }
-  return (0, import_babel_utils50.importNamed)(file, request, name2, nameHint);
+  return (0, import_babel_utils51.importNamed)(file, request, name2, nameHint);
 }
 function isCircularRequest(file, request) {
   const { filename } = file.opts;
@@ -12322,15 +12757,15 @@ function isCircularRequest(file, request) {
 }
 
 // src/translator/visitors/tag/dynamic-tag.ts
-var import_compiler63 = require("@marko/compiler");
-var import_babel_utils51 = require("@marko/compiler/babel-utils");
+var import_compiler64 = require("@marko/compiler");
+var import_babel_utils52 = require("@marko/compiler/babel-utils");
 var kDOMBinding3 = Symbol("dynamic tag dom binding");
 var kChildOffsetScopeBinding2 = Symbol("custom tag scope offset");
 var importedDynamicTagResume = /* @__PURE__ */ new WeakSet();
 var dynamic_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils51.assertAttributesOrArgs)(tag);
+      (0, import_babel_utils52.assertAttributesOrArgs)(tag);
       const { node } = tag;
       const definedBodySection = node.extra?.defineBodySection;
       if (definedBodySection) {
@@ -12355,9 +12790,9 @@ var dynamic_tag_default = {
         tagSection
       );
       if (hasVar || tag.node.attributes.some(
-        (attr) => import_compiler63.types.isMarkoSpreadAttribute(attr) || isEventOrChangeHandler(attr.name)
+        (attr) => import_compiler64.types.isMarkoSpreadAttribute(attr) || isEventOrChangeHandler(attr.name)
       )) {
-        (0, import_babel_utils51.getProgram)().node.extra.isInteractive = true;
+        (0, import_babel_utils52.getProgram)().node.extra.isInteractive = true;
       }
       if (hasVar) {
         trackVarReferences(tag, 5 /* derived */);
@@ -12395,7 +12830,7 @@ var dynamic_tag_default = {
         if (isOutputHTML()) {
           knownTagTranslateHTML(
             tag,
-            import_compiler63.types.memberExpression(tag.node.name, import_compiler63.types.identifier("content")),
+            import_compiler64.types.memberExpression(tag.node.name, import_compiler64.types.identifier("content")),
             definedBodySection,
             propTree
           );
@@ -12412,9 +12847,9 @@ var dynamic_tag_default = {
                   "render",
                   section,
                   void 0,
-                  import_compiler63.types.expressionStatement(
-                    import_compiler63.types.callExpression(
-                      import_compiler63.types.memberExpression(signal.identifier, import_compiler63.types.identifier("_")),
+                  import_compiler64.types.expressionStatement(
+                    import_compiler64.types.callExpression(
+                      import_compiler64.types.memberExpression(signal.identifier, import_compiler64.types.identifier("_")),
                       [
                         createScopeReadExpression(childBinding, section),
                         getScopeExpression(section, definedBodySection.parent)
@@ -12439,8 +12874,8 @@ var dynamic_tag_default = {
       const nodeBinding = tagExtra[kDOMBinding3];
       const isClassAPI = tagExtra.featureType === "class";
       let tagExpression = node.name;
-      if (import_compiler63.types.isStringLiteral(tagExpression)) {
-        tagExpression = (0, import_babel_utils51.importDefault)(
+      if (import_compiler64.types.isStringLiteral(tagExpression)) {
+        tagExpression = (0, import_babel_utils52.importDefault)(
           tag.hub.file,
           getTagRelativePath(tag),
           tagExpression.value
@@ -12448,15 +12883,15 @@ var dynamic_tag_default = {
       }
       if (isClassAPI) {
         if (isOutputHTML()) {
-          (0, import_babel_utils51.getProgram)().node.body.push(
-            import_compiler63.types.markoScriptlet(
+          (0, import_babel_utils52.getProgram)().node.body.push(
+            import_compiler64.types.markoScriptlet(
               [
-                import_compiler63.types.expressionStatement(
-                  import_compiler63.types.callExpression(
-                    (0, import_babel_utils51.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
+                import_compiler64.types.expressionStatement(
+                  import_compiler64.types.callExpression(
+                    (0, import_babel_utils52.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
                     [
-                      import_compiler63.types.identifier(tagExpression.name),
-                      import_compiler63.types.stringLiteral((0, import_babel_utils51.loadFileForTag)(tag).metadata.marko.id)
+                      import_compiler64.types.identifier(tagExpression.name),
+                      import_compiler64.types.stringLiteral((0, import_babel_utils52.loadFileForTag)(tag).metadata.marko.id)
                     ]
                   )
                 )
@@ -12465,12 +12900,12 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          (0, import_babel_utils51.getProgram)().node.body.push(
-            import_compiler63.types.expressionStatement(
+          (0, import_babel_utils52.getProgram)().node.body.push(
+            import_compiler64.types.expressionStatement(
               callRuntime(
                 "_resume",
-                import_compiler63.types.stringLiteral((0, import_babel_utils51.loadFileForTag)(tag).metadata.marko.id),
-                import_compiler63.types.identifier(tagExpression.name)
+                import_compiler64.types.stringLiteral((0, import_babel_utils52.loadFileForTag)(tag).metadata.marko.id),
+                import_compiler64.types.identifier(tagExpression.name)
               )
             )
           );
@@ -12480,6 +12915,7 @@ var dynamic_tag_default = {
         tag,
         void 0,
         void 0,
+        void 0,
         isClassAPI ? "renderBody" : "content"
       );
       const args = [];
@@ -12512,9 +12948,9 @@ var dynamic_tag_default = {
           getScopeIdIdentifier(tagSection),
           getScopeAccessorLiteral(nodeBinding),
           tagExpression,
-          import_compiler63.types.arrayExpression(args),
-          import_compiler63.types.numericLiteral(0),
-          import_compiler63.types.numericLiteral(1),
+          import_compiler64.types.arrayExpression(args),
+          import_compiler64.types.numericLiteral(0),
+          import_compiler64.types.numericLiteral(1),
           serializeArg
         ) : callRuntime(
           "_dynamic_tag",
@@ -12522,8 +12958,8 @@ var dynamic_tag_default = {
           getScopeAccessorLiteral(nodeBinding),
           tagExpression,
           args[0],
-          args[1] || (serializeArg ? import_compiler63.types.numericLiteral(0) : void 0),
-          serializeArg ? import_compiler63.types.numericLiteral(0) : void 0,
+          args[1] || (serializeArg ? import_compiler64.types.numericLiteral(0) : void 0),
+          serializeArg ? import_compiler64.types.numericLiteral(0) : void 0,
           serializeArg
         );
         if (node.var) {
@@ -12531,18 +12967,18 @@ var dynamic_tag_default = {
             tag.get("name").toString() + "_scope"
           );
           statements.push(
-            import_compiler63.types.variableDeclaration("const", [
-              import_compiler63.types.variableDeclarator(
+            import_compiler64.types.variableDeclaration("const", [
+              import_compiler64.types.variableDeclarator(
                 dynamicScopeIdentifier,
                 callRuntime("_peek_scope_id")
               )
             ])
           );
           statements.push(
-            import_compiler63.types.variableDeclaration("let", [
-              import_compiler63.types.variableDeclarator(node.var, dynamicTagExpr)
+            import_compiler64.types.variableDeclaration("let", [
+              import_compiler64.types.variableDeclarator(node.var, dynamicTagExpr)
             ]),
-            import_compiler63.types.expressionStatement(
+            import_compiler64.types.expressionStatement(
               callRuntime(
                 "_var",
                 getScopeIdIdentifier(tagSection),
@@ -12550,7 +12986,7 @@ var dynamic_tag_default = {
                   tag.node.extra[kChildOffsetScopeBinding2]
                 ),
                 dynamicScopeIdentifier,
-                import_compiler63.types.stringLiteral(
+                import_compiler64.types.stringLiteral(
                   getResumeRegisterId(
                     tagSection,
                     node.var.extra?.binding,
@@ -12562,7 +12998,7 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          statements.push(import_compiler63.types.expressionStatement(dynamicTagExpr));
+          statements.push(import_compiler64.types.expressionStatement(dynamicTagExpr));
         }
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -12581,9 +13017,9 @@ var dynamic_tag_default = {
           tagVarSignal.register = true;
           tagVarSignal.buildAssignment = (valueSection, value) => {
             const changeArgs = [
-              import_compiler63.types.memberExpression(
+              import_compiler64.types.memberExpression(
                 getScopeExpression(tagVarSignal.section, valueSection),
-                import_compiler63.types.stringLiteral(
+                import_compiler64.types.stringLiteral(
                   getAccessorPrefix().BranchScopes + getScopeAccessor(nodeBinding)
                 ),
                 true
@@ -12591,28 +13027,28 @@ var dynamic_tag_default = {
               value
             ];
             if (!isOptimize()) {
-              changeArgs.push(import_compiler63.types.stringLiteral(varBinding.name));
+              changeArgs.push(import_compiler64.types.stringLiteral(varBinding.name));
             }
-            return import_compiler63.types.callExpression(importRuntime("_var_change"), changeArgs);
+            return import_compiler64.types.callExpression(importRuntime("_var_change"), changeArgs);
           };
         }
         signal.build = () => {
           return callRuntime(
             "_dynamic_tag",
             getScopeAccessorLiteral(nodeBinding, true),
-            bodySection && import_compiler63.types.identifier(bodySection.name),
-            tagVarSignal ? import_compiler63.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
-            hasTagArgs && import_compiler63.types.numericLiteral(1)
+            bodySection && import_compiler64.types.identifier(bodySection.name),
+            tagVarSignal ? import_compiler64.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
+            hasTagArgs && import_compiler64.types.numericLiteral(1)
           );
         };
         if (args.length) {
-          const argsOrInput = hasTagArgs ? import_compiler63.types.arrayExpression(args) : args[0];
-          if (!import_compiler63.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
+          const argsOrInput = hasTagArgs ? import_compiler64.types.arrayExpression(args) : args[0];
+          if (!import_compiler64.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
             signal.extraArgs = [
-              import_compiler63.types.arrowFunctionExpression(
+              import_compiler64.types.arrowFunctionExpression(
                 [],
-                statements.length ? import_compiler63.types.blockStatement(
-                  statements.concat(import_compiler63.types.returnStatement(argsOrInput))
+                statements.length ? import_compiler64.types.blockStatement(
+                  statements.concat(import_compiler64.types.returnStatement(argsOrInput))
                 ) : argsOrInput
               )
             ];
@@ -12626,13 +13062,13 @@ var dynamic_tag_default = {
   }
 };
 function enableDynamicTagResume(tag) {
-  const program = (0, import_babel_utils51.getProgram)().node;
+  const program = (0, import_babel_utils52.getProgram)().node;
   if (!importedDynamicTagResume.has(program) && analyzeTagNameType(tag, true) !== 1 /* CustomTag */) {
     for (const attr of tag.node.attributes) {
       if (attr.type === "MarkoSpreadAttribute" || attr.type === "MarkoAttribute" && isEventOrChangeHandler(attr.name)) {
         importedDynamicTagResume.add(program);
         program.body.push(
-          import_compiler63.types.expressionStatement(callRuntime("_resume_dynamic_tag"))
+          import_compiler64.types.expressionStatement(callRuntime("_resume_dynamic_tag"))
         );
         return;
       }
@@ -12644,7 +13080,7 @@ function enableDynamicTagResume(tag) {
 var tag_default = {
   analyze: {
     enter(tag) {
-      const tagDef = (0, import_babel_utils52.getTagDef)(tag);
+      const tagDef = (0, import_babel_utils53.getTagDef)(tag);
       const type = analyzeTagNameType(tag);
       const hook = tagDef?.analyzer?.hook;
       if (hook) {
@@ -12668,7 +13104,7 @@ var tag_default = {
       }
     },
     exit(tag) {
-      const hook = (0, import_babel_utils52.getTagDef)(tag)?.analyzer?.hook;
+      const hook = (0, import_babel_utils53.getTagDef)(tag)?.analyzer?.hook;
       if (hook) {
         exit(hook, tag);
         return;
@@ -12677,7 +13113,7 @@ var tag_default = {
   },
   translate: {
     enter(tag) {
-      const tagDef = (0, import_babel_utils52.getTagDef)(tag);
+      const tagDef = (0, import_babel_utils53.getTagDef)(tag);
       const extra = tag.node.extra;
       if (tagDef?.translator) {
         if (tagDef.translator.path) {
@@ -12694,7 +13130,7 @@ var tag_default = {
             );
           }
           if (attr.node.modifier) {
-            if ((0, import_babel_utils52.isNativeTag)(attr.parentPath)) {
+            if ((0, import_babel_utils53.isNativeTag)(attr.parentPath)) {
               attr.node.name += `:${attr.node.modifier}`;
             } else {
               throw attr.buildCodeFrameError(
@@ -12708,8 +13144,8 @@ var tag_default = {
       if (extra.tagNameDynamic && extra.tagNameNullable && type === 0 /* NativeTag */ && !tag.get("name").isIdentifier() && isOutputHTML()) {
         const tagNameId = generateUidIdentifier("tagName");
         const [tagNameVarPath] = tag.insertBefore(
-          import_compiler64.types.variableDeclaration("const", [
-            import_compiler64.types.variableDeclarator(tagNameId, tag.node.name)
+          import_compiler65.types.variableDeclaration("const", [
+            import_compiler65.types.variableDeclarator(tagNameId, tag.node.name)
           ])
         );
         tagNameVarPath.skip();
@@ -12731,7 +13167,7 @@ var tag_default = {
       }
     },
     exit(tag) {
-      const translator = (0, import_babel_utils52.getTagDef)(tag)?.translator;
+      const translator = (0, import_babel_utils53.getTagDef)(tag)?.translator;
       if (translator) {
         exit(translator.hook, tag);
         return;
@@ -12755,7 +13191,7 @@ var tag_default = {
 };
 
 // src/translator/visitors/text.ts
-var import_compiler65 = require("@marko/compiler");
+var import_compiler66 = require("@marko/compiler");
 var text_default = {
   translate: {
     exit(text) {