marko 6.0.117 → 6.0.119

package/dist/translator/index.js

@@ -112,8 +112,8 @@ var attrs_default = {
 };
 
 // src/translator/core/await.ts
-var import_compiler36 = require("@marko/compiler");
-var import_babel_utils26 = require("@marko/compiler/babel-utils");
+var import_compiler39 = require("@marko/compiler");
+var import_babel_utils27 = require("@marko/compiler/babel-utils");
 
 // src/common/accessor.debug.ts
 var AccessorPrefix = /* @__PURE__ */ ((AccessorPrefix4) => {
@@ -248,8 +248,8 @@ function isNullableExpr(expr) {
 }
 
 // src/translator/util/references.ts
-var import_compiler35 = require("@marko/compiler");
-var import_babel_utils25 = require("@marko/compiler/babel-utils");
+var import_compiler38 = require("@marko/compiler");
+var import_babel_utils26 = require("@marko/compiler/babel-utils");
 
 // src/common/helpers.ts
 function classValue(classValue2) {
@@ -856,7 +856,16 @@ var import_babel_utils6 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/get-tag-name.ts
 function getTagName(tag) {
-  return tag.node.name.value;
+  switch (tag.node.name.type) {
+    case "StringLiteral":
+      return tag.node.name.value;
+    case "TemplateLiteral":
+      if (tag.node.name.quasis.length === 1) {
+        return tag.node.name.quasis[0].value.raw;
+      }
+      break;
+  }
+  return void 0;
 }
 
 // src/translator/util/is-core-tag.ts
@@ -869,13 +878,7 @@ function isCoreTag(tag) {
     if (tagDef) {
       switch (tagDef.taglibId) {
         case taglibId:
-          return true;
         case interopTaglibId:
-          switch (tagDef.name) {
-            // The body tag is registered in the v5 translator, without this it'd be seen as a core tag.
-            case "body":
-              return false;
-          }
           return true;
         case htmlTaglibId:
           switch (tagDef.name) {
@@ -1598,7 +1601,7 @@ function analyzeTagNameType(tag, allowDynamic) {
     if (name2.isStringLiteral()) {
       extra.tagNameType = name2.node.value[0] === "@" ? 3 /* AttributeTag */ : (0, import_babel_utils9.isNativeTag)(tag) ? 0 /* NativeTag */ : 1 /* CustomTag */;
       extra.tagNameNullable = extra.tagNameDynamic = false;
-    } else if (name2.isTemplateLiteral() && !name2.node.expressions.length) {
+    } else if (name2.isTemplateLiteral() && name2.node.quasis.length === 1) {
       extra.tagNameType = 0 /* NativeTag */;
       extra.tagNameNullable = extra.tagNameDynamic = false;
     } else if (name2.isIdentifier()) {
@@ -1839,7 +1842,6 @@ function getNodeContentType(path5, extraMember, contentInfo) {
             return 0 /* Comment */;
           case "html-script":
           case "html-style":
-          case "title":
             return 3 /* Tag */;
           case "for":
           case "if":
@@ -1993,7 +1995,6 @@ function isNativeNode(tag) {
       case "html-comment":
       case "html-script":
       case "html-style":
-      case "title":
         return true;
       default:
         return false;
@@ -2217,11 +2218,11 @@ function isEventOrChangeHandler(prop) {
 }
 
 // src/translator/util/known-tag.ts
-var import_compiler34 = require("@marko/compiler");
-var import_babel_utils24 = require("@marko/compiler/babel-utils");
+var import_compiler37 = require("@marko/compiler");
+var import_babel_utils25 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/program/index.ts
-var import_compiler26 = require("@marko/compiler");
+var import_compiler27 = require("@marko/compiler");
 var import_babel_utils17 = require("@marko/compiler/babel-utils");
 var import_path2 = __toESM(require("path"));
 
@@ -4783,7 +4784,31 @@ function getRegisteredFnExpression2(node) {
 }
 
 // src/translator/visitors/program/pre-analyze.ts
+var import_compiler26 = require("@marko/compiler");
+
+// src/translator/core/textarea.ts
 var import_compiler25 = require("@marko/compiler");
+function preAnalyze(tag) {
+  if (tag.node.body.body.length) {
+    const parts = [];
+    for (const child of tag.node.body.body) {
+      if (child.type === "MarkoText" || child.type === "MarkoPlaceholder" && child.escape) {
+        parts.push(child.value);
+      } else {
+        throw tag.hub.file.hub.buildError(
+          child,
+          "Unexpected content in textarea, only text and placeholders are supported.",
+          SyntaxError
+        );
+      }
+    }
+    const textValue = normalizeStringExpression(parts);
+    if (textValue) {
+      tag.node.attributes.push(import_compiler25.types.markoAttribute("value", textValue));
+    }
+    tag.node.body.body = [];
+  }
+}
 
 // src/translator/util/with-previous-location.ts
 function withPreviousLocation(newNode, originalNode) {
@@ -4796,7 +4821,7 @@ function withPreviousLocation(newNode, originalNode) {
 // src/translator/visitors/program/pre-analyze.ts
 var TAG_NAME_IDENTIFIER_REG = /^[A-Z][a-zA-Z0-9_$]*$/;
 var BINDING_CHANGE_HANDLER = /* @__PURE__ */ new WeakMap();
-function preAnalyze(program) {
+function preAnalyze2(program) {
   const state = { crawl: false };
   normalizeBody(state, program.get("body"));
   if (state.crawl) {
@@ -4838,12 +4863,18 @@ function normalizeTag(state, tag) {
     const tagName = name2.value;
     if (tag.scope.getBinding(tagName) && TAG_NAME_IDENTIFIER_REG.test(tagName)) {
       state.crawl = true;
-      node.name = withPreviousLocation(import_compiler25.types.identifier(tagName), name2);
+      node.name = withPreviousLocation(import_compiler26.types.identifier(tagName), name2);
+    } else {
+      switch (tagName) {
+        case "textarea":
+          preAnalyze(tag);
+          break;
+      }
     }
   }
   for (let i = 0; i < attributes.length; i++) {
     const attr = attributes[i];
-    if (import_compiler25.types.isMarkoAttribute(attr) && attr.bound) {
+    if (import_compiler26.types.isMarkoAttribute(attr) && attr.bound) {
       state.crawl = true;
       attr.bound = false;
       attributes.splice(++i, 0, getChangeHandler(tag, attr));
@@ -4853,10 +4884,10 @@ function normalizeTag(state, tag) {
 function getChangeHandler(tag, attr) {
   const attrName = attr.name;
   const changeAttrName = attrName + "Change";
-  if (import_compiler25.types.isIdentifier(attr.value)) {
+  if (import_compiler26.types.isIdentifier(attr.value)) {
     const binding = tag.scope.getBinding(attr.value.name);
     if (!binding)
-      return import_compiler25.types.markoAttribute(
+      return import_compiler26.types.markoAttribute(
         changeAttrName,
         buildChangeHandlerFunction(attr.value)
       );
@@ -4869,7 +4900,7 @@ function getChangeHandler(tag, attr) {
       if (!changeAttrExpr) {
         throw tag.hub.buildError(attr.value, "Unable to bind to value.");
       }
-      const changeHandlerAttr = import_compiler25.types.markoAttribute(
+      const changeHandlerAttr = import_compiler26.types.markoAttribute(
         changeAttrName,
         changeAttrExpr
       );
@@ -4877,10 +4908,10 @@ function getChangeHandler(tag, attr) {
       return changeHandlerAttr;
     }
     if (existingChangedAttr.type === "Identifier") {
-      return import_compiler25.types.markoAttribute(
+      return import_compiler26.types.markoAttribute(
         changeAttrName,
         withPreviousLocation(
-          import_compiler25.types.identifier(existingChangedAttr.name),
+          import_compiler26.types.identifier(existingChangedAttr.name),
           attr.value
         )
       );
@@ -4890,16 +4921,16 @@ function getChangeHandler(tag, attr) {
       throw tag.hub.buildError(attr.value, "Unable to bind to value.");
     }
     const changeHandlerId = generateUid(changeAttrName);
-    const changeHandlerConst = import_compiler25.types.markoTag(
-      import_compiler25.types.stringLiteral("const"),
-      [import_compiler25.types.markoAttribute("value", existingChangedAttr.value, null, null, true)],
-      import_compiler25.types.markoTagBody([]),
+    const changeHandlerConst = import_compiler26.types.markoTag(
+      import_compiler26.types.stringLiteral("const"),
+      [import_compiler26.types.markoAttribute("value", existingChangedAttr.value, null, null, true)],
+      import_compiler26.types.markoTagBody([]),
       null,
-      import_compiler25.types.identifier(changeHandlerId)
+      import_compiler26.types.identifier(changeHandlerId)
     );
     BINDING_CHANGE_HANDLER.set(
       binding.identifier,
-      existingChangedAttr.value = import_compiler25.types.identifier(changeHandlerId)
+      existingChangedAttr.value = import_compiler26.types.identifier(changeHandlerId)
     );
     if (markoRoot.isMarkoTag()) {
       markoRoot.insertAfter(changeHandlerConst);
@@ -4907,23 +4938,23 @@ function getChangeHandler(tag, attr) {
       markoRoot.unshiftContainer("body", changeHandlerConst);
     }
     markoRoot.scope.crawl();
-    return import_compiler25.types.markoAttribute(
+    return import_compiler26.types.markoAttribute(
       changeAttrName,
-      withPreviousLocation(import_compiler25.types.identifier(changeHandlerId), attr.value)
+      withPreviousLocation(import_compiler26.types.identifier(changeHandlerId), attr.value)
     );
-  } else if (import_compiler25.types.isMemberExpression(attr.value) || import_compiler25.types.isOptionalMemberExpression(attr.value)) {
+  } else if (import_compiler26.types.isMemberExpression(attr.value) || import_compiler26.types.isOptionalMemberExpression(attr.value)) {
     const prop = attr.value.property;
-    if (!import_compiler25.types.isPrivateName(attr.value.property)) {
-      const memberObj = import_compiler25.types.cloneNode(attr.value.object);
-      const memberProp = prop.type === "Identifier" ? withPreviousLocation(import_compiler25.types.identifier(prop.name + "Change"), prop) : import_compiler25.types.binaryExpression(
+    if (!import_compiler26.types.isPrivateName(attr.value.property)) {
+      const memberObj = import_compiler26.types.cloneNode(attr.value.object);
+      const memberProp = prop.type === "Identifier" ? withPreviousLocation(import_compiler26.types.identifier(prop.name + "Change"), prop) : import_compiler26.types.binaryExpression(
         "+",
-        import_compiler25.types.cloneNode(prop),
-        import_compiler25.types.stringLiteral("Change")
+        import_compiler26.types.cloneNode(prop),
+        import_compiler26.types.stringLiteral("Change")
       );
       const computed = memberProp.type !== "Identifier";
-      return import_compiler25.types.markoAttribute(
+      return import_compiler26.types.markoAttribute(
         changeAttrName,
-        attr.value.optional ? import_compiler25.types.optionalMemberExpression(memberObj, memberProp, computed, true) : import_compiler25.types.memberExpression(memberObj, memberProp, computed)
+        attr.value.optional ? import_compiler26.types.optionalMemberExpression(memberObj, memberProp, computed, true) : import_compiler26.types.memberExpression(memberObj, memberProp, computed)
       );
     }
   }
@@ -4934,14 +4965,14 @@ function getChangeHandler(tag, attr) {
 }
 function buildChangeHandlerFunction(id) {
   const newId = "_new_" + id.name;
-  return import_compiler25.types.arrowFunctionExpression(
-    [withPreviousLocation(import_compiler25.types.identifier(newId), id)],
-    import_compiler25.types.blockStatement([
-      import_compiler25.types.expressionStatement(
-        import_compiler25.types.assignmentExpression(
+  return import_compiler26.types.arrowFunctionExpression(
+    [withPreviousLocation(import_compiler26.types.identifier(newId), id)],
+    import_compiler26.types.blockStatement([
+      import_compiler26.types.expressionStatement(
+        import_compiler26.types.assignmentExpression(
           "=",
-          withPreviousLocation(import_compiler25.types.identifier(id.name), id),
-          withPreviousLocation(import_compiler25.types.identifier(newId), id)
+          withPreviousLocation(import_compiler26.types.identifier(id.name), id),
+          withPreviousLocation(import_compiler26.types.identifier(newId), id)
         )
       )
     ])
@@ -4954,11 +4985,11 @@ function getChangeHandlerFromObjectPattern(parent) {
     changeKey = generateUidIdentifier("dynamicChange");
     pattern.pushContainer(
       "properties",
-      import_compiler25.types.objectProperty(
-        import_compiler25.types.binaryExpression(
+      import_compiler26.types.objectProperty(
+        import_compiler26.types.binaryExpression(
           "+",
           parent.get("key").node,
-          import_compiler25.types.stringLiteral("Change")
+          import_compiler26.types.stringLiteral("Change")
         ),
         changeKey,
         true
@@ -4980,8 +5011,8 @@ function getChangeHandlerFromObjectPattern(parent) {
     if (!changeKey) {
       pattern.unshiftContainer(
         "properties",
-        import_compiler25.types.objectProperty(
-          import_compiler25.types.stringLiteral(searchKey),
+        import_compiler26.types.objectProperty(
+          import_compiler26.types.stringLiteral(searchKey),
           changeKey = generateUidIdentifier(searchKey)
         )
       );
@@ -5011,7 +5042,7 @@ function getAssignmentInsertions(node, insertions) {
               getLiteralName(left) || getLiteralName(prop.key) || "pattern"
             );
             prop.shorthand = false;
-            prop.value = import_compiler25.types.identifier(sourceName);
+            prop.value = import_compiler26.types.identifier(sourceName);
             (insertions ||= []).push(
               toConstTag(left, toFallbackExpr(sourceName, right))
             );
@@ -5029,7 +5060,7 @@ function getAssignmentInsertions(node, insertions) {
           if (el.type === "AssignmentPattern") {
             const { left, right } = el;
             const sourceName = generateUid(getLiteralName(left) || "pattern");
-            node.elements[i] = import_compiler25.types.identifier(sourceName);
+            node.elements[i] = import_compiler26.types.identifier(sourceName);
             (insertions ||= []).push(
               toConstTag(left, toFallbackExpr(sourceName, right))
             );
@@ -5044,23 +5075,23 @@ function getAssignmentInsertions(node, insertions) {
   return insertions;
 }
 function toFallbackExpr(id, fallback) {
-  return import_compiler25.types.conditionalExpression(
-    import_compiler25.types.binaryExpression("!==", buildUndefined(), import_compiler25.types.identifier(id)),
-    import_compiler25.types.identifier(id),
+  return import_compiler26.types.conditionalExpression(
+    import_compiler26.types.binaryExpression("!==", buildUndefined(), import_compiler26.types.identifier(id)),
+    import_compiler26.types.identifier(id),
     fallback
   );
 }
 function toConstTag(id, expr) {
-  return import_compiler25.types.markoTag(
-    import_compiler25.types.stringLiteral("const"),
-    [import_compiler25.types.markoAttribute("value", expr, null, null, true)],
-    import_compiler25.types.markoTagBody(),
+  return import_compiler26.types.markoTag(
+    import_compiler26.types.stringLiteral("const"),
+    [import_compiler26.types.markoAttribute("value", expr, null, null, true)],
+    import_compiler26.types.markoTagBody(),
     null,
     id
   );
 }
 function buildUndefined() {
-  return import_compiler25.types.unaryExpression("void", import_compiler25.types.numericLiteral(0));
+  return import_compiler26.types.unaryExpression("void", import_compiler26.types.numericLiteral(0));
 }
 
 // src/translator/visitors/program/index.ts
@@ -5072,14 +5103,14 @@ function isScopeIdentifier(node) {
 var program_default = {
   migrate: {
     enter(program) {
-      program.node.params = [import_compiler26.types.identifier("input")];
+      program.node.params = [import_compiler27.types.identifier("input")];
     },
     exit(program) {
       program.scope.crawl();
     }
   },
   transform: {
-    exit: preAnalyze
+    exit: preAnalyze2
   },
   analyze: {
     enter(program) {
@@ -5161,7 +5192,7 @@ var program_default = {
             body.push(child);
           }
         }
-        body[0] ??= import_compiler26.types.importDeclaration([], import_compiler26.types.stringLiteral(compatFile));
+        body[0] ??= import_compiler27.types.importDeclaration([], import_compiler27.types.stringLiteral(compatFile));
         program.node.body = body;
       }
     }
@@ -5175,7 +5206,7 @@ function resolveRelativeToEntry(entryFile, file, req) {
 }
 
 // src/translator/util/nested-attribute-tags.ts
-var import_compiler27 = require("@marko/compiler");
+var import_compiler28 = require("@marko/compiler");
 var import_babel_utils18 = require("@marko/compiler/babel-utils");
 var attrTagToIdentifierLookup = /* @__PURE__ */ new WeakMap();
 function getAttrTagIdentifier(meta) {
@@ -5184,7 +5215,7 @@ function getAttrTagIdentifier(meta) {
     name2 = generateUid(meta.name);
     attrTagToIdentifierLookup.set(meta, name2);
   }
-  return import_compiler27.types.identifier(name2);
+  return import_compiler28.types.identifier(name2);
 }
 function analyzeAttributeTags(tag) {
   if (tag.node.extra?.attributeTags) return tag.node.extra.attributeTags;
@@ -5297,7 +5328,7 @@ function getConditionRoot(tag) {
 }
 
 // src/translator/util/set-tag-sections-downstream.ts
-var import_compiler28 = require("@marko/compiler");
+var import_compiler29 = require("@marko/compiler");
 var import_babel_utils19 = require("@marko/compiler/babel-utils");
 var [getTagDownstreams] = createSectionState(
   "tag-downstreams",
@@ -5344,23 +5375,82 @@ function crawlSectionsAndSetBinding(tag, binding, tree, skip2) {
 }
 
 // src/translator/util/translate-attrs.ts
-var import_compiler33 = require("@marko/compiler");
-var import_babel_utils23 = require("@marko/compiler/babel-utils");
+var import_compiler36 = require("@marko/compiler");
+var import_babel_utils24 = require("@marko/compiler/babel-utils");
 
 // src/translator/core/for.ts
-var import_compiler32 = require("@marko/compiler");
-var import_babel_utils22 = require("@marko/compiler/babel-utils");
+var import_compiler35 = require("@marko/compiler");
+var import_babel_utils23 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/is-only-child-in-parent.ts
-var import_compiler31 = require("@marko/compiler");
-var import_babel_utils21 = require("@marko/compiler/babel-utils");
+var import_compiler34 = require("@marko/compiler");
+var import_babel_utils22 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/native-tag.ts
+var import_compiler33 = require("@marko/compiler");
+var import_babel_utils21 = require("@marko/compiler/babel-utils");
+
+// src/translator/util/body-to-text-literal.ts
 var import_compiler30 = require("@marko/compiler");
+function bodyToTextLiteral(body) {
+  const templateQuasis = [];
+  const templateExpressions = [];
+  let currentQuasi = "";
+  let placeholderExtra;
+  for (const child of body.body) {
+    if (import_compiler30.types.isMarkoText(child)) {
+      currentQuasi += child.value;
+    } else if (import_compiler30.types.isMarkoPlaceholder(child)) {
+      placeholderExtra ||= child.value.extra;
+      templateQuasis.push(templateElement(currentQuasi, false));
+      templateExpressions.push(callRuntime("_to_text", child.value));
+      currentQuasi = "";
+    }
+  }
+  if (templateExpressions.length) {
+    templateQuasis.push(templateElement(currentQuasi, true));
+    const literal = import_compiler30.types.templateLiteral(templateQuasis, templateExpressions);
+    literal.extra = placeholderExtra;
+    return literal;
+  }
+  return import_compiler30.types.stringLiteral(currentQuasi);
+}
+function templateElement(value, tail) {
+  return import_compiler30.types.templateElement(
+    {
+      raw: value.replace(/`/g, "\\`"),
+      cooked: value
+    },
+    tail
+  );
+}
+
+// src/translator/util/is-non-html-text.ts
+var import_compiler31 = require("@marko/compiler");
 var import_babel_utils20 = require("@marko/compiler/babel-utils");
+function isNonHTMLText(placeholder) {
+  const parentTag = placeholder.parentPath.isMarkoTagBody() && placeholder.parentPath.parentPath;
+  if (parentTag) {
+    if (isCoreTag(parentTag)) {
+      switch (parentTag.node.name.value) {
+        case "html-comment":
+        case "html-script":
+        case "html-style":
+          return true;
+      }
+    } else if (isTextOnlyNativeTag(parentTag)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isTextOnlyNativeTag(tag) {
+  const def = (0, import_babel_utils20.getTagDef)(tag);
+  return !!(def && def.html && (def.name === "title" || def.parseOptions?.text));
+}
 
 // src/translator/util/translate-var.ts
-var import_compiler29 = require("@marko/compiler");
+var import_compiler32 = require("@marko/compiler");
 function translateVar(tag, initialValue, kind = "const") {
   const {
     node: { var: tagVar }
@@ -5378,15 +5468,15 @@ function translateVar(tag, initialValue, kind = "const") {
     if (changeBinding && changeName !== changeBinding.name) {
       getDestructurePattern(id)?.pushContainer(
         "properties",
-        import_compiler29.types.objectProperty(
-          import_compiler29.types.identifier(changeName),
-          import_compiler29.types.identifier(changeBinding.name)
+        import_compiler32.types.objectProperty(
+          import_compiler32.types.identifier(changeName),
+          import_compiler32.types.identifier(changeBinding.name)
         )
       );
     }
   });
   tag.insertBefore(
-    import_compiler29.types.variableDeclaration(kind, [import_compiler29.types.variableDeclarator(tagVar, initialValue)])
+    import_compiler32.types.variableDeclaration(kind, [import_compiler32.types.variableDeclarator(tagVar, initialValue)])
   );
 }
 function translateDomVar(tag, binding) {
@@ -5396,13 +5486,13 @@ function translateDomVar(tag, binding) {
     if (registerId) {
       tag.parentPath.unshiftContainer(
         "body",
-        import_compiler29.types.variableDeclaration("const", [
-          import_compiler29.types.variableDeclarator(
+        import_compiler32.types.variableDeclaration("const", [
+          import_compiler32.types.variableDeclarator(
             tag.node.var,
             callRuntime(
               "_el",
               getScopeIdIdentifier(tagSection),
-              import_compiler29.types.stringLiteral(registerId)
+              import_compiler32.types.stringLiteral(registerId)
             )
           )
         ])
@@ -5428,65 +5518,83 @@ var htmlSelectArgs = /* @__PURE__ */ new WeakMap();
 var native_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils20.assertNoArgs)(tag);
-      (0, import_babel_utils20.assertNoParams)(tag);
-      (0, import_babel_utils20.assertNoAttributeTags)(tag);
+      (0, import_babel_utils21.assertNoArgs)(tag);
+      (0, import_babel_utils21.assertNoParams)(tag);
+      (0, import_babel_utils21.assertNoAttributeTags)(tag);
       const { node } = tag;
-      if (node.var && !import_compiler30.types.isIdentifier(node.var)) {
+      if (node.var && !import_compiler33.types.isIdentifier(node.var)) {
         throw tag.get("var").buildCodeFrameError(
           "Tag variables on [native tags](https://markojs.com/docs/reference/native-tag) cannot be destructured."
         );
       }
-      const tagName = getTagName(tag);
+      const tagName = getCanonicalTagName(tag);
+      const isTextOnly = isTextOnlyNativeTag(tag);
       const seen = {};
       const { attributes } = tag.node;
+      let injectNonce = isInjectNonceTag(tagName);
       let hasDynamicAttributes = false;
       let hasEventHandlers = false;
       let relatedControllable;
       let spreadReferenceNodes;
-      let attrExprExtras;
+      let exprExtras;
       for (let i = attributes.length; i--; ) {
         const attr = attributes[i];
         const valueExtra = attr.value.extra ??= {};
-        if (import_compiler30.types.isMarkoAttribute(attr)) {
+        if (import_compiler33.types.isMarkoAttribute(attr)) {
           if (seen[attr.name]) {
             dropReferences(attr.value);
             continue;
           }
           seen[attr.name] = attr;
+          if (injectNonce && attr.name === "nonce") {
+            injectNonce = false;
+          }
           if (isEventHandler(attr.name) || isNativeTagChangeHandler(attr.name)) {
             valueExtra.isEffect = true;
             hasEventHandlers = true;
           } else if (!evaluate(attr.value).confident) {
             hasDynamicAttributes = true;
           }
-        } else if (import_compiler30.types.isMarkoSpreadAttribute(attr)) {
+        } else if (import_compiler33.types.isMarkoSpreadAttribute(attr)) {
           valueExtra.isEffect = true;
           hasEventHandlers = true;
           hasDynamicAttributes = true;
         }
         if (spreadReferenceNodes) {
           spreadReferenceNodes.push(attr.value);
-        } else if (import_compiler30.types.isMarkoSpreadAttribute(attr)) {
+        } else if (import_compiler33.types.isMarkoSpreadAttribute(attr)) {
           spreadReferenceNodes = [attr.value];
           relatedControllable = getRelatedControllable(tagName, seen);
         } else {
-          attrExprExtras = push(attrExprExtras, valueExtra);
+          exprExtras = push(exprExtras, valueExtra);
         }
       }
       assertExclusiveAttrs(seen, (msg) => {
         throw tag.get("name").buildCodeFrameError(msg);
       });
-      if (node.var || hasEventHandlers || hasDynamicAttributes || getRelatedControllable(tagName, seen)?.special) {
+      let textPlaceholders;
+      if (isTextOnly) {
+        for (const child of tag.node.body.body) {
+          if (import_compiler33.types.isMarkoPlaceholder(child)) {
+            (textPlaceholders ||= []).push(child.value);
+          } else if (!import_compiler33.types.isMarkoText(child)) {
+            throw tag.hub.buildError(
+              child,
+              `Only text is allowed inside a \`<${tagName}>\`.`
+            );
+          }
+        }
+      }
+      if (node.var || hasDynamicAttributes || hasEventHandlers || textPlaceholders || injectNonce || getRelatedControllable(tagName, seen)?.special) {
         const tagExtra = node.extra ??= {};
         const tagSection = getOrCreateSection(tag);
         const nodeBinding = tagExtra[kNativeTagBinding] = createBinding(
-          "#" + (node.name.type === "StringLiteral" ? node.name.value : import_compiler30.types.toIdentifier(tag.get("name"))),
+          "#" + getCanonicalTagName(tag),
           0 /* dom */,
           tagSection
         );
         if (hasEventHandlers) {
-          (0, import_babel_utils20.getProgram)().node.extra.isInteractive = true;
+          (0, import_babel_utils21.getProgram)().node.extra.isInteractive = true;
         }
         if (spreadReferenceNodes) {
           if (relatedControllable && !relatedControllable.attrs.every(Boolean)) {
@@ -5508,38 +5616,50 @@ var native_tag_default = {
             relatedControllable.attrs.map((it) => it?.value)
           );
         }
+        if (textPlaceholders) {
+          exprExtras = push(
+            exprExtras,
+            textPlaceholders.length === 1 ? textPlaceholders[0].extra ??= {} : mergeReferences(
+              tagSection,
+              textPlaceholders[0],
+              textPlaceholders.slice(1)
+            )
+          );
+        }
         addSerializeExpr(
           tagSection,
           !!(node.var || hasEventHandlers),
           nodeBinding
         );
         trackDomVarReferences(tag, nodeBinding);
-        addSerializeExpr(
-          tagSection,
-          push(attrExprExtras, tagExtra),
-          nodeBinding
-        );
+        addSerializeExpr(tagSection, push(exprExtras, tagExtra), nodeBinding);
       }
     }
   },
   translate: translateByTarget({
     html: {
       enter(tag) {
-        const tagName = getTagName(tag);
+        const tagName = getCanonicalTagName(tag);
         const tagExtra = tag.node.extra;
         const nodeBinding = tagExtra[kNativeTagBinding];
-        const tagDef = (0, import_babel_utils20.getTagDef)(tag);
+        const tagDef = (0, import_babel_utils21.getTagDef)(tag);
         const write = writeTo(tag);
         const tagSection = getSection(tag);
-        if (tagExtra.tagNameNullable) {
-          flushBefore(tag);
-        }
         translateDomVar(tag, nodeBinding);
         const visitAccessor = nodeBinding && getScopeAccessorLiteral(nodeBinding);
-        write`<${tag.node.name}`;
+        write`<${tagName}`;
         const usedAttrs = getUsedAttrs(tagName, tag.node);
-        const { staticAttrs, staticControllable, skipExpression } = usedAttrs;
+        const {
+          staticAttrs,
+          staticControllable,
+          staticContentAttr,
+          skipExpression,
+          injectNonce
+        } = usedAttrs;
         let { spreadExpression } = usedAttrs;
+        if (injectNonce) {
+          write`${callRuntime("_attr_nonce")}`;
+        }
         if (staticControllable) {
           if (tagName !== "select" && tagName !== "textarea") {
             write`${callRuntime(
@@ -5563,18 +5683,18 @@ var native_tag_default = {
           } else if (spreadExpression) {
             const spreadIdentifier = generateUidIdentifier("select_input");
             tag.insertBefore(
-              import_compiler30.types.variableDeclaration("const", [
-                import_compiler30.types.variableDeclarator(spreadIdentifier, spreadExpression)
+              import_compiler33.types.variableDeclaration("const", [
+                import_compiler33.types.variableDeclarator(spreadIdentifier, spreadExpression)
               ])
             );
             htmlSelectArgs.set(tag.node, {
-              value: import_compiler30.types.memberExpression(
+              value: import_compiler33.types.memberExpression(
                 spreadIdentifier,
-                import_compiler30.types.identifier("value")
+                import_compiler33.types.identifier("value")
               ),
-              valueChange: import_compiler30.types.memberExpression(
+              valueChange: import_compiler33.types.memberExpression(
                 spreadIdentifier,
-                import_compiler30.types.identifier("valueChange")
+                import_compiler33.types.identifier("valueChange")
               )
             });
             spreadExpression = spreadIdentifier;
@@ -5588,14 +5708,14 @@ var native_tag_default = {
           } else if (spreadExpression) {
             const spreadIdentifier = generateUidIdentifier("textarea_input");
             tag.insertBefore(
-              import_compiler30.types.variableDeclaration("const", [
-                import_compiler30.types.variableDeclarator(spreadIdentifier, spreadExpression)
+              import_compiler33.types.variableDeclaration("const", [
+                import_compiler33.types.variableDeclarator(spreadIdentifier, spreadExpression)
               ])
             );
-            value = import_compiler30.types.memberExpression(spreadIdentifier, import_compiler30.types.identifier("value"));
-            valueChange = import_compiler30.types.memberExpression(
+            value = import_compiler33.types.memberExpression(spreadIdentifier, import_compiler33.types.identifier("value"));
+            valueChange = import_compiler33.types.memberExpression(
               spreadIdentifier,
-              import_compiler30.types.identifier("valueChange")
+              import_compiler33.types.identifier("valueChange")
             );
             spreadExpression = spreadIdentifier;
           }
@@ -5608,7 +5728,7 @@ var native_tag_default = {
               valueChange
             );
           } else if (value) {
-            writeAtStartOfBody = callRuntime("_to_text", value);
+            writeAtStartOfBody = callRuntime("_escape_text", value);
           }
         }
         for (const attr of staticAttrs) {
@@ -5636,20 +5756,34 @@ var native_tag_default = {
               } else if (isEventHandler(name2)) {
                 addHTMLEffectCall(tagSection, valueReferences);
               } else {
-                write`${callRuntime("_attr", import_compiler30.types.stringLiteral(name2), value)}`;
+                write`${callRuntime("_attr", import_compiler33.types.stringLiteral(name2), value)}`;
               }
               break;
           }
         }
         const isOpenOnly = !!(tagDef && tagDef.parseOptions?.openTagOnly);
+        const isTextOnly = isTextOnlyNativeTag(tag);
         const hasChildren = !!tag.node.body.body.length;
         if (spreadExpression) {
           addHTMLEffectCall(tagSection, tagExtra.referencedBindings);
-          if (isOpenOnly || hasChildren || usedAttrs.staticContentAttr) {
+          if (isTextOnly || isOpenOnly || hasChildren || staticContentAttr) {
             if (skipExpression) {
-              write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), tag.node.name)}`;
+              write`${callRuntime(
+                "_attrs_partial",
+                spreadExpression,
+                skipExpression,
+                visitAccessor,
+                getScopeIdIdentifier(tagSection),
+                import_compiler33.types.stringLiteral(tagName)
+              )}`;
             } else {
-              write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), tag.node.name)}`;
+              write`${callRuntime(
+                "_attrs",
+                spreadExpression,
+                visitAccessor,
+                getScopeIdIdentifier(tagSection),
+                import_compiler33.types.stringLiteral(tagName)
+              )}`;
             }
           }
         }
@@ -5663,62 +5797,57 @@ var native_tag_default = {
               write`>`;
               break;
           }
-        } else {
-          if (usedAttrs.staticContentAttr) {
-            write`>`;
-            tagExtra[kTagContentAttr] = true;
-            tag.node.body.body = [
-              import_compiler30.types.expressionStatement(
-                callRuntime(
-                  "_attr_content",
-                  visitAccessor,
-                  getScopeIdIdentifier(tagSection),
-                  usedAttrs.staticContentAttr.value,
-                  getSerializeGuard(
-                    tagSection,
-                    nodeBinding && getSerializeReason(tagSection, nodeBinding),
-                    true
-                  )
+        } else if (isTextOnly) {
+          write`>`;
+        } else if (staticContentAttr) {
+          write`>`;
+          tagExtra[kTagContentAttr] = true;
+          tag.node.body.body = [
+            import_compiler33.types.expressionStatement(
+              callRuntime(
+                "_attr_content",
+                visitAccessor,
+                getScopeIdIdentifier(tagSection),
+                staticContentAttr.value,
+                getSerializeGuard(
+                  tagSection,
+                  nodeBinding && getSerializeReason(tagSection, nodeBinding),
+                  true
                 )
               )
-            ];
-          } else if (spreadExpression && !hasChildren) {
-            const serializeReason = getSerializeGuard(
-              tagSection,
-              nodeBinding && getSerializeReason(tagSection, nodeBinding),
-              true
-            );
-            tagExtra[kTagContentAttr] = true;
-            tag.node.body.body = [
-              skipExpression ? import_compiler30.types.expressionStatement(
-                callRuntime(
-                  "_attrs_partial_content",
-                  spreadExpression,
-                  skipExpression,
-                  visitAccessor,
-                  getScopeIdIdentifier(tagSection),
-                  tag.node.name,
-                  serializeReason
-                )
-              ) : import_compiler30.types.expressionStatement(
-                callRuntime(
-                  "_attrs_content",
-                  spreadExpression,
-                  visitAccessor,
-                  getScopeIdIdentifier(tagSection),
-                  tag.node.name,
-                  serializeReason
-                )
+            )
+          ];
+        } else if (spreadExpression && !hasChildren) {
+          const serializeReason = getSerializeGuard(
+            tagSection,
+            nodeBinding && getSerializeReason(tagSection, nodeBinding),
+            true
+          );
+          tagExtra[kTagContentAttr] = true;
+          tag.node.body.body = [
+            skipExpression ? import_compiler33.types.expressionStatement(
+              callRuntime(
+                "_attrs_partial_content",
+                spreadExpression,
+                skipExpression,
+                visitAccessor,
+                getScopeIdIdentifier(tagSection),
+                import_compiler33.types.stringLiteral(tagName),
+                serializeReason
               )
-            ];
-          } else {
-            write`>`;
-          }
-        }
-        if (tagExtra.tagNameNullable) {
-          tag.insertBefore(
-            import_compiler30.types.ifStatement(tag.node.name, consumeHTML(tag))
-          )[0].skip();
+            ) : import_compiler33.types.expressionStatement(
+              callRuntime(
+                "_attrs_content",
+                spreadExpression,
+                visitAccessor,
+                getScopeIdIdentifier(tagSection),
+                import_compiler33.types.stringLiteral(tagName),
+                serializeReason
+              )
+            )
+          ];
+        } else {
+          write`>`;
         }
         if (writeAtStartOfBody) {
           write`${writeAtStartOfBody}`;
@@ -5727,50 +5856,52 @@ var native_tag_default = {
       exit(tag) {
         const tagExtra = tag.node.extra;
         const nodeBinding = tagExtra[kNativeTagBinding];
-        const openTagOnly = (0, import_babel_utils20.getTagDef)(tag)?.parseOptions?.openTagOnly;
+        const isOpenOnly = (0, import_babel_utils21.getTagDef)(tag)?.parseOptions?.openTagOnly;
+        const isTextOnly = isTextOnlyNativeTag(tag);
         const selectArgs = htmlSelectArgs.get(tag.node);
-        const tagName = getTagName(tag);
+        const tagName = getCanonicalTagName(tag);
         const tagSection = getSection(tag);
+        const markerSerializeReason = !tagExtra[kSkipEndTag] && nodeBinding && getSerializeReason(tagSection, nodeBinding);
+        const write = writeTo(
+          tag,
+          !markerSerializeReason && (tagName === "html" || tagName === "body")
+        );
         if (tagExtra[kTagContentAttr]) {
           flushBefore(tag);
         }
-        if (tagExtra.tagNameNullable) {
-          flushInto(tag);
-        }
         if (selectArgs) {
           if (!tagExtra[kSkipEndTag]) {
-            writeTo(tag)`</${tag.node.name}>`;
+            write`</${tagName}>`;
           }
           flushInto(tag);
           tag.insertBefore(
-            import_compiler30.types.expressionStatement(
+            import_compiler33.types.expressionStatement(
               callRuntime(
                 "_attr_select_value",
                 getScopeIdIdentifier(getSection(tag)),
                 nodeBinding && getScopeAccessorLiteral(nodeBinding),
                 selectArgs.value,
                 selectArgs.valueChange,
-                import_compiler30.types.arrowFunctionExpression(
+                import_compiler33.types.arrowFunctionExpression(
                   [],
-                  import_compiler30.types.blockStatement(tag.node.body.body)
+                  import_compiler33.types.blockStatement(tag.node.body.body)
                 )
               )
             )
           );
+        } else if (isTextOnly) {
+          for (const child of tag.node.body.body) {
+            if (import_compiler33.types.isMarkoText(child)) {
+              write`${child.value}`;
+            } else if (import_compiler33.types.isMarkoPlaceholder(child)) {
+              write`${callRuntime(getTextOnlyEscapeHelper(tagName), child.value)}`;
+            }
+          }
         } else {
           tag.insertBefore(tag.node.body.body).forEach((child) => child.skip());
         }
-        const markerSerializeReason = !tagExtra[kSkipEndTag] && nodeBinding && getSerializeReason(tagSection, nodeBinding);
-        if (!tagExtra[kSkipEndTag] && !openTagOnly && !selectArgs) {
-          writeTo(
-            tag,
-            !markerSerializeReason && (tagName === "html" || tagName === "body")
-          )`</${tag.node.name}>`;
-        }
-        if (tagExtra.tagNameNullable) {
-          tag.insertBefore(
-            import_compiler30.types.ifStatement(tag.node.name, consumeHTML(tag))
-          )[0].skip();
+        if (!tagExtra[kSkipEndTag] && !isOpenOnly && !selectArgs) {
+          write`</${tagName}>`;
         }
         if (markerSerializeReason) {
           markNode(tag, nodeBinding, markerSerializeReason);
@@ -5780,22 +5911,42 @@ var native_tag_default = {
     },
     dom: {
       enter(tag) {
-        const tagName = getTagName(tag);
+        const tagName = getCanonicalTagName(tag);
         const tagExtra = tag.node.extra;
         const nodeBinding = tagExtra[kNativeTagBinding];
-        const tagDef = (0, import_babel_utils20.getTagDef)(tag);
+        const tagDef = (0, import_babel_utils21.getTagDef)(tag);
         const write = writeTo(tag);
         const tagSection = getSection(tag);
         const visitAccessor = nodeBinding && getScopeAccessorLiteral(nodeBinding);
         if (nodeBinding) {
           visit(tag, 32 /* Get */);
         }
-        write`<${tag.node.name}`;
-        const usedAttrs = getUsedAttrs(tagName, tag.node);
-        const { staticAttrs, staticControllable, skipExpression } = usedAttrs;
-        const { spreadExpression } = usedAttrs;
+        write`<${tagName}`;
+        const {
+          staticAttrs,
+          staticControllable,
+          staticContentAttr,
+          skipExpression,
+          spreadExpression,
+          injectNonce
+        } = getUsedAttrs(tagName, tag.node);
         const isOpenOnly = !!(tagDef && tagDef.parseOptions?.openTagOnly);
+        const isTextOnly = isTextOnlyNativeTag(tag);
         const hasChildren = !!tag.node.body.body.length;
+        if (injectNonce) {
+          addStatement(
+            "render",
+            tagSection,
+            void 0,
+            import_compiler33.types.expressionStatement(
+              callRuntime(
+                "_attr_nonce",
+                scopeIdentifier,
+                getScopeAccessorLiteral(nodeBinding)
+              )
+            )
+          );
+        }
         if (staticControllable) {
           const { helper, attrs } = staticControllable;
           const firstAttr = attrs.find(Boolean);
@@ -5805,7 +5956,7 @@ var native_tag_default = {
             "render",
             tagSection,
             referencedBindings,
-            import_compiler30.types.expressionStatement(
+            import_compiler33.types.expressionStatement(
               callRuntime(helper, scopeIdentifier, visitAccessor, ...values)
             )
           );
@@ -5814,7 +5965,7 @@ var native_tag_default = {
               "effect",
               tagSection,
               void 0,
-              import_compiler30.types.expressionStatement(
+              import_compiler33.types.expressionStatement(
                 callRuntime(`${helper}_script`, scopeIdentifier, visitAccessor)
               )
             );
@@ -5840,7 +5991,7 @@ var native_tag_default = {
                 let stmt;
                 trackDelimitedAttrValue(value, meta);
                 if (meta.dynamicItems) {
-                  stmt = import_compiler30.types.expressionStatement(
+                  stmt = import_compiler33.types.expressionStatement(
                     callRuntime(helper, nodeExpr, value)
                   );
                 } else {
@@ -5852,11 +6003,11 @@ var native_tag_default = {
                     if (keys.length === 1) {
                       const [key] = keys;
                       const value2 = meta.dynamicValues[key];
-                      stmt = import_compiler30.types.expressionStatement(
+                      stmt = import_compiler33.types.expressionStatement(
                         callRuntime(
                           `_attr_${name2}_item`,
                           nodeExpr,
-                          import_compiler30.types.stringLiteral(key),
+                          import_compiler33.types.stringLiteral(key),
                           value2
                         )
                       );
@@ -5865,14 +6016,14 @@ var native_tag_default = {
                       for (const key of keys) {
                         const value2 = meta.dynamicValues[key];
                         props.push(
-                          import_compiler30.types.objectProperty(toPropertyName(key), value2)
+                          import_compiler33.types.objectProperty(toPropertyName(key), value2)
                         );
                       }
-                      stmt = import_compiler30.types.expressionStatement(
+                      stmt = import_compiler33.types.expressionStatement(
                         callRuntime(
                           `_attr_${name2}_items`,
                           nodeExpr,
-                          import_compiler30.types.objectExpression(props)
+                          import_compiler33.types.objectExpression(props)
                         )
                       );
                     }
@@ -5892,11 +6043,11 @@ var native_tag_default = {
                   "effect",
                   tagSection,
                   valueReferences,
-                  import_compiler30.types.expressionStatement(
+                  import_compiler33.types.expressionStatement(
                     callRuntime(
                       "_on",
                       createScopeReadExpression(nodeBinding),
-                      import_compiler30.types.stringLiteral(getEventHandlerName(name2)),
+                      import_compiler33.types.stringLiteral(getEventHandlerName(name2)),
                       value
                     )
                   )
@@ -5906,11 +6057,11 @@ var native_tag_default = {
                   "render",
                   tagSection,
                   valueReferences,
-                  import_compiler30.types.expressionStatement(
+                  import_compiler33.types.expressionStatement(
                     callRuntime(
                       "_attr",
                       createScopeReadExpression(nodeBinding),
-                      import_compiler30.types.stringLiteral(name2),
+                      import_compiler33.types.stringLiteral(name2),
                       value
                     )
                   )
@@ -5920,13 +6071,13 @@ var native_tag_default = {
           }
         }
         if (spreadExpression) {
-          const canHaveAttrContent = !(isOpenOnly || hasChildren || usedAttrs.staticContentAttr);
+          const canHaveAttrContent = !(isTextOnly || isOpenOnly || hasChildren || staticContentAttr);
           if (skipExpression) {
             addStatement(
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler30.types.expressionStatement(
+              import_compiler33.types.expressionStatement(
                 callRuntime(
                   canHaveAttrContent ? "_attrs_partial_content" : "_attrs_partial",
                   scopeIdentifier,
@@ -5941,7 +6092,7 @@ var native_tag_default = {
               "render",
               tagSection,
               tagExtra.referencedBindings,
-              import_compiler30.types.expressionStatement(
+              import_compiler33.types.expressionStatement(
                 callRuntime(
                   canHaveAttrContent ? "_attrs_content" : "_attrs",
                   scopeIdentifier,
@@ -5955,24 +6106,23 @@ var native_tag_default = {
             "effect",
             tagSection,
             tagExtra.referencedBindings,
-            import_compiler30.types.expressionStatement(
+            import_compiler33.types.expressionStatement(
               callRuntime("_attrs_script", scopeIdentifier, visitAccessor)
             ),
             false
           );
         }
-        if (usedAttrs.staticContentAttr) {
-          const contentAttrValue = usedAttrs.staticContentAttr.value;
+        if (staticContentAttr) {
           addStatement(
             "render",
             tagSection,
-            contentAttrValue.extra?.referencedBindings,
-            import_compiler30.types.expressionStatement(
+            staticContentAttr.value.extra?.referencedBindings,
+            import_compiler33.types.expressionStatement(
               callRuntime(
                 "_attr_content",
                 scopeIdentifier,
                 visitAccessor,
-                contentAttrValue
+                staticContentAttr.value
               )
             )
           );
@@ -5993,10 +6143,34 @@ var native_tag_default = {
         enter2(tag);
       },
       exit(tag) {
-        const openTagOnly = (0, import_babel_utils20.getTagDef)(tag)?.parseOptions?.openTagOnly;
-        tag.insertBefore(tag.node.body.body).forEach((child) => child.skip());
+        const tagExtra = tag.node.extra;
+        const nodeBinding = tagExtra[kNativeTagBinding];
+        const openTagOnly = (0, import_babel_utils21.getTagDef)(tag)?.parseOptions?.openTagOnly;
+        const tagName = getCanonicalTagName(tag);
         if (!openTagOnly) {
-          writeTo(tag)`</${tag.node.name}>`;
+          const write = writeTo(tag);
+          if (tagName !== "textarea" && isTextOnlyNativeTag(tag)) {
+            const textLiteral = bodyToTextLiteral(tag.node.body);
+            if (import_compiler33.types.isStringLiteral(textLiteral)) {
+              write`${textLiteral}`;
+            } else {
+              addStatement(
+                "render",
+                getSection(tag),
+                textLiteral.extra?.referencedBindings,
+                import_compiler33.types.expressionStatement(
+                  callRuntime(
+                    "_text_content",
+                    createScopeReadExpression(nodeBinding),
+                    textLiteral
+                  )
+                )
+              );
+            }
+          } else {
+            tag.insertBefore(tag.node.body.body).forEach((child) => child.skip());
+          }
+          write`</${tagName}>`;
         }
         exit2(tag);
         tag.remove();
@@ -6069,10 +6243,11 @@ function getUsedAttrs(tagName, tag) {
   let skipProps;
   let staticControllable;
   let staticContentAttr;
+  let injectNonce = isInjectNonceTag(tagName);
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     const { value } = attr;
-    if (import_compiler30.types.isMarkoSpreadAttribute(attr)) {
+    if (import_compiler33.types.isMarkoSpreadAttribute(attr)) {
       if (!spreadProps) {
         spreadProps = [];
         staticControllable = getRelatedControllable(tagName, seen);
@@ -6086,9 +6261,12 @@ function getUsedAttrs(tagName, tag) {
           staticControllable = void 0;
         }
       }
-      spreadProps.push(import_compiler30.types.spreadElement(value));
+      spreadProps.push(import_compiler33.types.spreadElement(value));
     } else if (!(seen[attr.name] || attr.name === "content" && tag.body.body.length)) {
       seen[attr.name] = attr;
+      if (injectNonce && attr.name === "nonce") {
+        injectNonce = false;
+      }
       if (spreadProps) {
         spreadProps.push(toObjectProperty(attr.name, attr.value));
       } else if (attr.name === "content" && tagName !== "meta") {
@@ -6113,25 +6291,37 @@ function getUsedAttrs(tagName, tag) {
   }
   const staticAttrs = [...maybeStaticAttrs].reverse();
   if (spreadProps) {
-    spreadProps.reverse();
     if (staticControllable) {
       for (const attr of staticControllable.attrs) {
         if (attr) {
           (skipProps ||= []).push(
-            toObjectProperty(attr.name, import_compiler30.types.numericLiteral(1))
+            toObjectProperty(attr.name, import_compiler33.types.numericLiteral(1))
           );
         }
       }
     }
     for (const { name: name2 } of staticAttrs) {
-      (skipProps ||= []).push(toObjectProperty(name2, import_compiler30.types.numericLiteral(1)));
+      (skipProps ||= []).push(toObjectProperty(name2, import_compiler33.types.numericLiteral(1)));
+    }
+    if (injectNonce) {
+      injectNonce = false;
+      spreadProps.push(
+        import_compiler33.types.objectProperty(
+          import_compiler33.types.identifier("nonce"),
+          import_compiler33.types.memberExpression(
+            isOutputHTML() ? callRuntime("$global") : toMemberExpression(scopeIdentifier, getAccessorProp().Global),
+            import_compiler33.types.identifier("cspNonce")
+          )
+        )
+      );
     }
-    spreadExpression = propsToExpression(spreadProps);
+    spreadExpression = propsToExpression(spreadProps.reverse());
   }
   if (skipProps) {
-    skipExpression = import_compiler30.types.objectExpression(skipProps);
+    skipExpression = import_compiler33.types.objectExpression(skipProps);
   }
   return {
+    injectNonce,
     staticAttrs,
     staticContentAttr,
     staticControllable,
@@ -6139,6 +6329,36 @@ function getUsedAttrs(tagName, tag) {
     skipExpression
   };
 }
+function isInjectNonceTag(tagName) {
+  switch (tagName) {
+    case "script":
+    case "style":
+      return true;
+    default:
+      return false;
+  }
+}
+function getCanonicalTagName(tag) {
+  const tagName = getTagName(tag);
+  switch (tagName) {
+    case "html-script":
+      return "script";
+    case "html-style":
+      return "style";
+    default:
+      return tagName;
+  }
+}
+function getTextOnlyEscapeHelper(tagName) {
+  switch (tagName) {
+    case "script":
+      return "_escape_script";
+    case "style":
+      return "_escape_style";
+    default:
+      return "_escape_text";
+  }
+}
 function trackDelimitedAttrValue(expr, meta) {
   switch (expr.type) {
     case "ObjectExpression":
@@ -6216,14 +6436,14 @@ function trackDelimitedAttrObjectProperties(obj, meta) {
     (meta.staticItems ||= []).push(staticProps);
   }
   if (dynamicProps) {
-    (meta.dynamicItems ||= []).push(import_compiler30.types.objectExpression(dynamicProps));
+    (meta.dynamicItems ||= []).push(import_compiler33.types.objectExpression(dynamicProps));
   }
 }
 function isNativeTagChangeHandler(propName) {
   return /^(?:value|checked(?:Value)?|open)Change$/.test(propName);
 }
 function buildUndefined2() {
-  return import_compiler30.types.unaryExpression("void", import_compiler30.types.numericLiteral(0));
+  return import_compiler33.types.unaryExpression("void", import_compiler33.types.numericLiteral(0));
 }
 
 // src/translator/util/is-only-child-in-parent.ts
@@ -6235,7 +6455,7 @@ function getOnlyChildParentTagName(tag, branchSize = 1) {
     return extra[kOnlyChildInParent];
   }
   const parentTag = getParentTag(tag);
-  return extra[kOnlyChildInParent] = parentTag && (0, import_babel_utils21.getTagDef)(parentTag)?.html && parentTag.node.name.type === "StringLiteral" && tag.parent.body.length === branchSize ? parentTag.node.name.value : false;
+  return extra[kOnlyChildInParent] = parentTag && (0, import_babel_utils22.getTagDef)(parentTag)?.html && parentTag.node.name.type === "StringLiteral" && tag.parent.body.length === branchSize ? parentTag.node.name.value : false;
 }
 function getOptimizedOnlyChildNodeBinding(tag, section, branchSize = 1) {
   if (getOnlyChildParentTagName(tag, branchSize)) {
@@ -6267,8 +6487,8 @@ var for_default = {
       isAttrTag ? 4 /* local */ : 5 /* derived */
     );
     let allowAttrs;
-    (0, import_babel_utils22.assertNoVar)(tag);
-    (0, import_babel_utils22.assertNoArgs)(tag);
+    (0, import_babel_utils23.assertNoVar)(tag);
+    (0, import_babel_utils23.assertNoArgs)(tag);
     assertNoSpreadAttrs(tag);
     switch (getForType(tag.node)) {
       case "of":
@@ -6291,7 +6511,7 @@ var for_default = {
     if (!isAttrTag) {
       allowAttrs.push("by");
     }
-    (0, import_babel_utils22.assertAllowedAttributes)(tag, allowAttrs);
+    (0, import_babel_utils23.assertAllowedAttributes)(tag, allowAttrs);
     if (isAttrTag) return;
     const bodySection = startSection(tagBody);
     if (!bodySection) {
@@ -6359,7 +6579,7 @@ var for_default = {
         const forTagArgs = getBaseArgsInForTag(forType, forAttrs);
         const forTagHTMLRuntime = branchSerializeReason ? forTypeToHTMLResumeRuntime(forType) : forTypeToRuntime(forType);
         forTagArgs.push(
-          import_compiler32.types.arrowFunctionExpression(params, import_compiler32.types.blockStatement(bodyStatements))
+          import_compiler35.types.arrowFunctionExpression(params, import_compiler35.types.blockStatement(bodyStatements))
         );
         if (branchSerializeReason) {
           const skipParentEnd = onlyChildParentTagName && markerSerializeReason;
@@ -6374,7 +6594,7 @@ var for_default = {
             !statefulSerializeArg
           );
           forTagArgs.push(
-            forAttrs.by || import_compiler32.types.numericLiteral(0),
+            forAttrs.by || import_compiler35.types.numericLiteral(0),
             getScopeIdIdentifier(tagSection),
             getScopeAccessorLiteral(nodeBinding),
             getSerializeGuard(
@@ -6387,17 +6607,17 @@ var for_default = {
           );
           if (skipParentEnd) {
             getParentTag(tag).node.extra[kSkipEndTag] = true;
-            forTagArgs.push(import_compiler32.types.stringLiteral(`</${onlyChildParentTagName}>`));
+            forTagArgs.push(import_compiler35.types.stringLiteral(`</${onlyChildParentTagName}>`));
           }
           if (singleChild) {
             if (!skipParentEnd) {
-              forTagArgs.push(import_compiler32.types.numericLiteral(0));
+              forTagArgs.push(import_compiler35.types.numericLiteral(0));
             }
-            forTagArgs.push(import_compiler32.types.numericLiteral(1));
+            forTagArgs.push(import_compiler35.types.numericLiteral(1));
           }
         }
         statements.push(
-          import_compiler32.types.expressionStatement(callRuntime(forTagHTMLRuntime, ...forTagArgs))
+          import_compiler35.types.expressionStatement(callRuntime(forTagHTMLRuntime, ...forTagArgs))
         );
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -6455,7 +6675,7 @@ var for_default = {
           tagSection,
           referencedBindings,
           signal,
-          import_compiler32.types.arrayExpression(loopArgs)
+          import_compiler35.types.arrayExpression(loopArgs)
         );
         tag.remove();
       }
@@ -6533,11 +6753,11 @@ var for_default = {
   ]
 };
 function buildForRuntimeCall(type, attrs, params, statements) {
-  return import_compiler32.types.expressionStatement(
+  return import_compiler35.types.expressionStatement(
     callRuntime(
       forTypeToRuntime(type),
       ...getBaseArgsInForTag(type, attrs),
-      import_compiler32.types.arrowFunctionExpression(params, import_compiler32.types.blockStatement(statements))
+      import_compiler35.types.arrowFunctionExpression(params, import_compiler35.types.blockStatement(statements))
     )
   );
 }
@@ -6599,14 +6819,14 @@ function getBaseArgsInForTag(type, attrs) {
     case "to":
       return [
         attrs.to,
-        attrs.from || import_compiler32.types.numericLiteral(0),
-        attrs.step || import_compiler32.types.numericLiteral(1)
+        attrs.from || import_compiler35.types.numericLiteral(0),
+        attrs.step || import_compiler35.types.numericLiteral(1)
       ];
     case "until":
       return [
         attrs.until,
-        attrs.from || import_compiler32.types.numericLiteral(0),
-        attrs.step || import_compiler32.types.numericLiteral(1)
+        attrs.from || import_compiler35.types.numericLiteral(0),
+        attrs.step || import_compiler35.types.numericLiteral(1)
       ];
   }
 }
@@ -6625,8 +6845,8 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
         seen.add(attrTagMeta.name);
         if (attrTagMeta.dynamic) {
           statements.push(
-            import_compiler33.types.variableDeclaration("let", [
-              import_compiler33.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta))
+            import_compiler36.types.variableDeclaration("let", [
+              import_compiler36.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta))
             ])
           );
           properties.push(
@@ -6642,7 +6862,7 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
     for (let i = 0; i < attrTags2.length; i++) {
       const child = attrTags2[i];
       if (child.isMarkoTag()) {
-        if ((0, import_babel_utils23.isAttributeTag)(child)) {
+        if ((0, import_babel_utils24.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
           if (attrTagMeta.dynamic) {
             i = addDynamicAttrTagStatements(
@@ -6708,8 +6928,8 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
   if (!seen.has(contentKey) && usesExport(templateExports, contentKey)) {
     const contentExpression = buildContent(tag.get("body"));
     if (contentExpression) {
-      const contentProp = import_compiler33.types.objectProperty(
-        import_compiler33.types.identifier(contentKey),
+      const contentProp = import_compiler36.types.objectProperty(
+        import_compiler36.types.identifier(contentKey),
         contentExpression
       );
       seen.add(contentKey);
@@ -6721,8 +6941,8 @@ function translateAttrs(tag, propTree, skip2, statements = [], contentKey = "con
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
     const { value } = attr;
-    if (import_compiler33.types.isMarkoSpreadAttribute(attr)) {
-      properties.push(import_compiler33.types.spreadElement(value));
+    if (import_compiler36.types.isMarkoSpreadAttribute(attr)) {
+      properties.push(import_compiler36.types.spreadElement(value));
     } else if (!seen.has(attr.name) && usesExport(templateExports, attr.name)) {
       seen.add(attr.name);
       properties.push(toObjectProperty(attr.name, value));
@@ -6741,7 +6961,7 @@ function getTranslatedBodyContentProperty(props) {
 function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements, templateExports, contentKey = "content") {
   const tag = attrTags2[index];
   if (tag.isMarkoTag()) {
-    if ((0, import_babel_utils23.isAttributeTag)(tag)) {
+    if ((0, import_babel_utils24.isAttributeTag)(tag)) {
       const attrTagMeta = attrTagLookup[getTagName(tag)];
       if (usesExport(templateExports, attrTagMeta.name) && attrTagMeta.dynamic) {
         const translatedAttrTag = translateAttrs(
@@ -6753,8 +6973,8 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
         );
         if (attrTagMeta.repeated) {
           statements.push(
-            import_compiler33.types.expressionStatement(
-              import_compiler33.types.assignmentExpression(
+            import_compiler36.types.expressionStatement(
+              import_compiler36.types.assignmentExpression(
                 "=",
                 getAttrTagIdentifier(attrTagMeta),
                 callRuntime(
@@ -6767,8 +6987,8 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
           );
         } else {
           statements.push(
-            import_compiler33.types.expressionStatement(
-              import_compiler33.types.assignmentExpression(
+            import_compiler36.types.expressionStatement(
+              import_compiler36.types.assignmentExpression(
                 "=",
                 getAttrTagIdentifier(attrTagMeta),
                 callRuntime(
@@ -6807,7 +7027,7 @@ function addDynamicAttrTagStatements(attrTags2, index, attrTagLookup, statements
   return index;
 }
 function propsToExpression(props) {
-  return props.length === 1 && import_compiler33.types.isSpreadElement(props[0]) ? props[0].argument : import_compiler33.types.objectExpression(props);
+  return props.length === 1 && import_compiler36.types.isSpreadElement(props[0]) ? props[0].argument : import_compiler36.types.objectExpression(props);
 }
 function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templateExports, contentKey) {
   const forTag = attrTags2[index];
@@ -6832,9 +7052,9 @@ function translateForAttrTag(attrTags2, index, attrTagLookup, statements, templa
 function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templateExports, contentKey) {
   const ifTag = attrTags2[index];
   const consequentStatements = [];
-  let ifStatement = import_compiler33.types.ifStatement(
+  let ifStatement = import_compiler36.types.ifStatement(
     getConditionTestValue(ifTag),
-    import_compiler33.types.blockStatement(consequentStatements)
+    import_compiler36.types.blockStatement(consequentStatements)
   );
   statements.push(ifStatement);
   addAllAttrTagsAsDynamic(
@@ -6861,14 +7081,14 @@ function translateIfAttrTag(attrTags2, index, attrTagLookup, statements, templat
             contentKey
           );
           if (testValue) {
-            ifStatement.alternate = ifStatement = import_compiler33.types.ifStatement(
+            ifStatement.alternate = ifStatement = import_compiler36.types.ifStatement(
               testValue,
-              import_compiler33.types.blockStatement(alternateStatements)
+              import_compiler36.types.blockStatement(alternateStatements)
             );
             nextIndex++;
             continue;
           } else {
-            ifStatement.alternate = import_compiler33.types.blockStatement(alternateStatements);
+            ifStatement.alternate = import_compiler36.types.blockStatement(alternateStatements);
             break;
           }
         }
@@ -6934,9 +7154,9 @@ function buildContent(body) {
       }
       if (dynamicSerializeReason) {
         body.node.body.unshift(
-          import_compiler33.types.variableDeclaration("const", [
-            import_compiler33.types.variableDeclarator(
-              import_compiler33.types.identifier(
+          import_compiler36.types.variableDeclaration("const", [
+            import_compiler36.types.variableDeclarator(
+              import_compiler36.types.identifier(
                 getSharedUid(`scope${bodySection.id}_reason`, bodySection)
               ),
               callRuntime("_scope_reason")
@@ -6946,10 +7166,10 @@ function buildContent(body) {
       }
       return callRuntime(
         serialized ? "_content_resume" : "_content",
-        import_compiler33.types.stringLiteral(getResumeRegisterId(bodySection, "content")),
-        import_compiler33.types.arrowFunctionExpression(
+        import_compiler36.types.stringLiteral(getResumeRegisterId(bodySection, "content")),
+        import_compiler36.types.arrowFunctionExpression(
           body.node.params,
-          import_compiler33.types.blockStatement(body.node.body)
+          import_compiler36.types.blockStatement(body.node.body)
         ),
         serialized ? getScopeIdIdentifier(
           getSection(
@@ -6960,17 +7180,17 @@ function buildContent(body) {
         ) : void 0
       );
     } else {
-      return import_compiler33.types.callExpression(
-        import_compiler33.types.identifier(bodySection.name),
+      return import_compiler36.types.callExpression(
+        import_compiler36.types.identifier(bodySection.name),
         bodySection.referencedLocalClosures ? [
           scopeIdentifier,
-          import_compiler33.types.objectExpression(
+          import_compiler36.types.objectExpression(
             toArray(bodySection.referencedLocalClosures, (ref) => {
               const accessor = getScopeAccessor(ref, true);
               const isShorthand = accessor === ref.name;
-              return import_compiler33.types.objectProperty(
+              return import_compiler36.types.objectProperty(
                 toPropertyName(accessor),
-                import_compiler33.types.identifier(ref.name),
+                import_compiler36.types.identifier(ref.name),
                 false,
                 isShorthand
               );
@@ -7055,8 +7275,8 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
   if (childScopeSerializeReason) {
     const peekScopeId = generateUidIdentifier(childScopeBinding?.name);
     tag.insertBefore(
-      import_compiler34.types.variableDeclaration("const", [
-        import_compiler34.types.variableDeclarator(peekScopeId, callRuntime("_peek_scope_id"))
+      import_compiler37.types.variableDeclaration("const", [
+        import_compiler37.types.variableDeclarator(peekScopeId, callRuntime("_peek_scope_id"))
       ])
     );
     setBindingSerializedValue(
@@ -7066,13 +7286,13 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
     );
     if (tagVar) {
       statements.push(
-        import_compiler34.types.expressionStatement(
+        import_compiler37.types.expressionStatement(
           callRuntime(
             "_var",
             getScopeIdIdentifier(section),
             getScopeAccessorLiteral(tag.node.extra[kChildOffsetScopeBinding]),
             peekScopeId,
-            import_compiler34.types.stringLiteral(
+            import_compiler37.types.stringLiteral(
               getResumeRegisterId(
                 section,
                 node.var.extra?.binding,
@@ -7101,9 +7321,9 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
         if (reason) {
           hasDynamicReasons ||= reason !== true && !reason.state;
           props.push(
-            import_compiler34.types.objectProperty(
+            import_compiler37.types.objectProperty(
               withLeadingComment(
-                import_compiler34.types.numericLiteral(i),
+                import_compiler37.types.numericLiteral(i),
                 getDebugNames(group.reason)
               ),
               getSerializeGuard(section, reason, false)
@@ -7114,12 +7334,12 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
         }
       }
       if (props.length) {
-        childSerializeReasonExpr = hasDynamicReasons || hasSkippedReasons ? import_compiler34.types.objectExpression(props) : import_compiler34.types.numericLiteral(1);
+        childSerializeReasonExpr = hasDynamicReasons || hasSkippedReasons ? import_compiler37.types.objectExpression(props) : import_compiler37.types.numericLiteral(1);
       }
     }
     if (childSerializeReasonExpr) {
       tag.insertBefore(
-        import_compiler34.types.expressionStatement(
+        import_compiler37.types.expressionStatement(
           callRuntime("_set_serialize_reason", childSerializeReasonExpr)
         )
       );
@@ -7135,39 +7355,7 @@ function knownTagTranslateHTML(tag, tagIdentifier, contentSection, propTree) {
     }
     return renderArgs;
   };
-  if (node.extra.tagNameNullable) {
-    const contentProp = getTranslatedBodyContentProperty(properties);
-    let contentId = void 0;
-    if (contentProp) {
-      const contentExpression = contentProp.value;
-      contentProp.value = contentId = generateUidIdentifier("content");
-      const [contentPath] = tag.insertBefore(
-        import_compiler34.types.variableDeclaration("const", [
-          import_compiler34.types.variableDeclarator(
-            contentId,
-            // TODO: only register if needed (child template analysis)
-            contentExpression
-          )
-        ])
-      );
-      contentPath.skip();
-    }
-    let renderTagExpr = callExpression(
-      tagIdentifier,
-      ...getArgs()
-    );
-    if (tagVar) {
-      translateVar(tag, import_compiler34.types.unaryExpression("void", import_compiler34.types.numericLiteral(0)), "let");
-      renderTagExpr = import_compiler34.types.assignmentExpression("=", tagVar, renderTagExpr);
-    }
-    statements.push(
-      import_compiler34.types.ifStatement(
-        tagIdentifier,
-        import_compiler34.types.expressionStatement(renderTagExpr),
-        contentId && callStatement(contentId)
-      )
-    );
-  } else if (tagVar) {
+  if (tagVar) {
     translateVar(tag, callExpression(tagIdentifier, ...getArgs()), "let");
   } else {
     statements.push(callStatement(tagIdentifier, ...getArgs()));
@@ -7194,15 +7382,15 @@ function knownTagTranslateDOM(tag, propTree, getBindingIdentifier, callSetup) {
         value
       ];
       if (!isOptimize()) {
-        changeArgs.push(import_compiler34.types.stringLiteral(varBinding.name));
+        changeArgs.push(import_compiler37.types.stringLiteral(varBinding.name));
       }
-      return import_compiler34.types.callExpression(importRuntime("_var_change"), changeArgs);
+      return import_compiler37.types.callExpression(importRuntime("_var_change"), changeArgs);
     };
     addStatement(
       "render",
       tagSection,
       void 0,
-      import_compiler34.types.expressionStatement(
+      import_compiler37.types.expressionStatement(
         callRuntime(
           "_var",
           scopeIdentifier,
@@ -7247,7 +7435,7 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     dropReferences(getAllTagReferenceNodes(tag.node));
     return inputExpr;
   }
-  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler34.types.isSpreadElement(node))) {
+  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler37.types.isSpreadElement(node))) {
     const extra = inputExpr.value = mergeReferences(
       section,
       tag.node,
@@ -7322,7 +7510,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     const attrTags2 = tag.node.body.attributeTags ? tag.get("body").get("body") : tag.get("attributeTags");
     for (const child of attrTags2) {
       if (child.isMarkoTag()) {
-        if ((0, import_babel_utils24.isAttributeTag)(child)) {
+        if ((0, import_babel_utils25.isAttributeTag)(child)) {
           const attrTagMeta = attrTagLookup[getTagName(child)];
           const childAttrExports = propTree.props[attrTagMeta.name];
           if (childAttrExports) {
@@ -7398,7 +7586,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   let spreadReferenceNodes;
   for (let i = attributes.length; i--; ) {
     const attr = attributes[i];
-    if (import_compiler34.types.isMarkoAttribute(attr)) {
+    if (import_compiler37.types.isMarkoAttribute(attr)) {
       const templateExportAttr = propTree.props[attr.name];
       if (!templateExportAttr || seen.has(attr.name)) {
         unknownReferences.push(attr.value);
@@ -7412,7 +7600,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
     }
     if (spreadReferenceNodes) {
       spreadReferenceNodes.push(attr.value);
-    } else if (import_compiler34.types.isMarkoSpreadAttribute(attr)) {
+    } else if (import_compiler37.types.isMarkoSpreadAttribute(attr)) {
       spreadReferenceNodes = [attr.value];
     } else {
       const attrValueExtra = attr.value.extra ??= {};
@@ -7454,7 +7642,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
   return inputExpr;
 }
 function writeParamsToSignals(tag, propTree, importAlias, info) {
-  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler34.types.isSpreadElement(node))) {
+  if (!propTree.props || tag.node.arguments?.some((node) => import_compiler37.types.isSpreadElement(node))) {
     const referencedBindings = tag.node.extra?.referencedBindings;
     const tagInputIdentifier = info.getBindingIdentifier(
       propTree.binding,
@@ -7482,8 +7670,8 @@ function writeParamsToSignals(tag, propTree, importAlias, info) {
       "render",
       info.tagSection,
       referencedBindings,
-      import_compiler34.types.expressionStatement(
-        import_compiler34.types.callExpression(tagInputIdentifier, [import_compiler34.types.arrayExpression(renderArgs)])
+      import_compiler37.types.expressionStatement(
+        import_compiler37.types.callExpression(tagInputIdentifier, [import_compiler37.types.arrayExpression(renderArgs)])
       )
     );
     return;
@@ -7502,8 +7690,8 @@ function writeParamsToSignals(tag, propTree, importAlias, info) {
           info.tagSection,
           arg.extra?.referencedBindings,
           // TODO: pretty sure content needs to have the reference group of it's param defaults.
-          import_compiler34.types.expressionStatement(
-            import_compiler34.types.callExpression(argExportIdentifier, [
+          import_compiler37.types.expressionStatement(
+            import_compiler37.types.callExpression(argExportIdentifier, [
               createScopeReadExpression(
                 info.childScopeBinding,
                 info.tagSection
@@ -7555,7 +7743,7 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
       for (let i = 0; i < attrTags2.length; i++) {
         const child = attrTags2[i];
         if (child.isMarkoTag()) {
-          if ((0, import_babel_utils24.isAttributeTag)(child)) {
+          if ((0, import_babel_utils25.isAttributeTag)(child)) {
             const attrTagMeta = attrTagLookup[getTagName(child)];
             const childAttrExport = propTree.props[attrTagMeta.name];
             if (childAttrExport) {
@@ -7591,17 +7779,17 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
             childAttrExports.binding,
             `${importAlias}_${attrTagMeta.name}`
           );
-          decls.push(import_compiler34.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
+          decls.push(import_compiler37.types.variableDeclarator(getAttrTagIdentifier(attrTagMeta)));
           addStatement("render", info.tagSection, referencedBindings, [
-            import_compiler34.types.variableDeclaration("let", decls),
+            import_compiler37.types.variableDeclaration("let", decls),
             ...statements
           ]);
           addStatement(
             "render",
             info.tagSection,
             referencedBindings,
-            import_compiler34.types.expressionStatement(
-              import_compiler34.types.callExpression(attrExportIdentifier, [
+            import_compiler37.types.expressionStatement(
+              import_compiler37.types.callExpression(attrExportIdentifier, [
                 createScopeReadExpression(
                   info.childScopeBinding,
                   info.tagSection
@@ -7626,13 +7814,13 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
           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, [
+          import_compiler37.types.expressionStatement(
+            import_compiler37.types.callExpression(contentExportIdentifier, [
               createScopeReadExpression(
                 info.childScopeBinding,
                 info.tagSection
               ),
-              import_compiler34.types.callExpression(import_compiler34.types.identifier(bodySection.name), [
+              import_compiler37.types.callExpression(import_compiler37.types.identifier(bodySection.name), [
                 scopeIdentifier
               ])
             ])
@@ -7645,7 +7833,7 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
     let spreadProps;
     for (let i = attributes.length; i--; ) {
       const attr = attributes[i];
-      if (import_compiler34.types.isMarkoAttribute(attr)) {
+      if (import_compiler37.types.isMarkoAttribute(attr)) {
         const childAttrExports = propTree.props[attr.name];
         if (!childAttrExports || seen.has(attr.name)) continue;
         if (spreadProps) {
@@ -7655,9 +7843,9 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         seen.add(attr.name);
         staticAttrs.push(attr);
       } else if (spreadProps) {
-        spreadProps.push(import_compiler34.types.spreadElement(attr.value));
+        spreadProps.push(import_compiler37.types.spreadElement(attr.value));
       } else {
-        spreadProps = [import_compiler34.types.spreadElement(attr.value)];
+        spreadProps = [import_compiler37.types.spreadElement(attr.value)];
       }
     }
     for (const attr of staticAttrs.reverse()) {
@@ -7670,8 +7858,8 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         "render",
         info.tagSection,
         attr.value.extra?.referencedBindings,
-        import_compiler34.types.expressionStatement(
-          import_compiler34.types.callExpression(attrExportIdentifier, [
+        import_compiler37.types.expressionStatement(
+          import_compiler37.types.callExpression(attrExportIdentifier, [
             createScopeReadExpression(info.childScopeBinding, info.tagSection),
             attr.value
           ])
@@ -7691,11 +7879,11 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         } else {
           spreadId = generateUidIdentifier(`${importAlias}_spread`);
           if (translatedAttrs) {
-            translatedAttrs.properties = [import_compiler34.types.spreadElement(spreadId)];
+            translatedAttrs.properties = [import_compiler37.types.spreadElement(spreadId)];
           }
           addStatement("render", info.tagSection, referencedBindings, [
-            import_compiler34.types.variableDeclaration("const", [
-              import_compiler34.types.variableDeclarator(spreadId, spreadExpr)
+            import_compiler37.types.variableDeclaration("const", [
+              import_compiler37.types.variableDeclarator(spreadId, spreadExpr)
             ])
           ]);
         }
@@ -7710,15 +7898,15 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
           "render",
           info.tagSection,
           referencedBindings,
-          import_compiler34.types.expressionStatement(
-            import_compiler34.types.callExpression(
+          import_compiler37.types.expressionStatement(
+            import_compiler37.types.callExpression(
               attrExportIdentifier,
               spreadId ? [
                 createScopeReadExpression(
                   info.childScopeBinding,
                   info.tagSection
                 ),
-                toMemberExpression(import_compiler34.types.cloneNode(spreadId, true), name2)
+                toMemberExpression(import_compiler37.types.cloneNode(spreadId, true), name2)
               ] : [
                 createScopeReadExpression(
                   info.childScopeBinding,
@@ -7758,12 +7946,12 @@ 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);
+      const restId = import_compiler37.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);
+        const shorthand = propId.type === "Identifier" && import_compiler37.types.isValidIdentifier(name2);
         props.push(
-          import_compiler34.types.objectProperty(
+          import_compiler37.types.objectProperty(
             propId,
             shorthand ? propId : generateUidIdentifier(name2),
             false,
@@ -7771,13 +7959,13 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
           )
         );
       });
-      props.push(import_compiler34.types.restElement(restId));
-      translatedProps = import_compiler34.types.callExpression(
-        import_compiler34.types.arrowFunctionExpression([import_compiler34.types.objectPattern(props)], restId),
+      props.push(import_compiler37.types.restElement(restId));
+      translatedProps = import_compiler37.types.callExpression(
+        import_compiler37.types.arrowFunctionExpression([import_compiler37.types.objectPattern(props)], restId),
         [spreadId]
       );
     }
-    if ((0, import_babel_utils24.isAttributeTag)(tag)) {
+    if ((0, import_babel_utils25.isAttributeTag)(tag)) {
       const attrTagName = getTagName(tag);
       const parentTag = tag.parentPath;
       const repeated = analyzeAttributeTags(parentTag)?.[attrTagName]?.repeated;
@@ -7802,7 +7990,7 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
         } else {
           attrTagCallsForTag.set(
             attrTagName,
-            translatedProps = import_compiler34.types.parenthesizedExpression(
+            translatedProps = import_compiler37.types.parenthesizedExpression(
               callRuntime("attrTag", translatedProps)
             )
           );
@@ -7815,8 +8003,8 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
       "render",
       info.tagSection,
       referencedBindings,
-      import_compiler34.types.expressionStatement(
-        import_compiler34.types.callExpression(tagInputIdentifier, [
+      import_compiler37.types.expressionStatement(
+        import_compiler37.types.callExpression(tagInputIdentifier, [
           createScopeReadExpression(info.childScopeBinding, info.tagSection),
           translatedProps
         ])
@@ -7851,10 +8039,10 @@ function mapParamReasonToExpr(exprs, reason) {
   }
 }
 function callStatement(id, ...args) {
-  return import_compiler34.types.expressionStatement(callExpression(id, ...args));
+  return import_compiler37.types.expressionStatement(callExpression(id, ...args));
 }
 function callExpression(id, ...args) {
-  return import_compiler34.types.callExpression(id, args.filter(Boolean));
+  return import_compiler37.types.callExpression(id, args.filter(Boolean));
 }
 function isSimpleReference(expr) {
   switch (expr.type) {
@@ -7917,7 +8105,7 @@ function trackDomVarReferences(tag, binding) {
   if (!tagVar) {
     return;
   }
-  if (!import_compiler35.types.isIdentifier(tagVar)) {
+  if (!import_compiler38.types.isIdentifier(tagVar)) {
     throw tag.get("var").buildCodeFrameError(
       "Tag variables on native elements cannot be destructured."
     );
@@ -8017,7 +8205,7 @@ function trackParamsReferences(body, type, upstreamAlias) {
           void 0,
           i > 0 ? addNumericPropertiesUntil(void 0, i - 1) : void 0
         );
-      } else if (import_compiler35.types.isLVal(param)) {
+      } else if (import_compiler38.types.isLVal(param)) {
         createBindingsAndTrackReferences(
           param,
           type,
@@ -8222,7 +8410,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
           if (hasRest) {
             excludeProperties = propsUtil.add(excludeProperties, key);
           }
-          if (import_compiler35.types.isLVal(prop.value)) {
+          if (import_compiler38.types.isLVal(prop.value)) {
             createBindingsAndTrackReferences(
               prop.value,
               type,
@@ -8262,7 +8450,7 @@ function createBindingsAndTrackReferences(lVal, type, scope, section, upstreamAl
               property,
               excludeProperties
             );
-          } else if (import_compiler35.types.isLVal(element)) {
+          } else if (import_compiler38.types.isLVal(element)) {
             createBindingsAndTrackReferences(
               element,
               type,
@@ -8285,7 +8473,7 @@ function trackReference(referencePath, binding) {
   let propPath = binding.name;
   while (true) {
     const { parent } = root;
-    if (!import_compiler35.types.isMemberExpression(parent) && !import_compiler35.types.isOptionalMemberExpression(parent))
+    if (!import_compiler38.types.isMemberExpression(parent) && !import_compiler38.types.isOptionalMemberExpression(parent))
       break;
     const prop = getMemberExpressionPropString(parent);
     if (prop === void 0) break;
@@ -8626,7 +8814,7 @@ function finalizeReferences() {
       });
     }
   });
-  const programExtra = (0, import_babel_utils25.getProgram)().node.extra;
+  const programExtra = (0, import_babel_utils26.getProgram)().node.extra;
   if (programExtra.returnValueExpr) {
     programExtra.section.returnSerializeReason = getSerializeSourcesForExpr(
       programExtra.returnValueExpr
@@ -8858,11 +9046,11 @@ function getAllTagReferenceNodes(tag, referenceNodes = []) {
 function getScopeAccessorLiteral(binding, encoded, includeId) {
   const canonicalBinding = getCanonicalBinding(binding);
   if (isOptimize()) {
-    return encoded ? import_compiler35.types.numericLiteral(canonicalBinding.id) : import_compiler35.types.stringLiteral(decodeAccessor(canonicalBinding.id));
+    return encoded ? import_compiler38.types.numericLiteral(canonicalBinding.id) : import_compiler38.types.stringLiteral(decodeAccessor(canonicalBinding.id));
   } else if (includeId || canonicalBinding.type === 0 /* dom */) {
-    return import_compiler35.types.stringLiteral(`${canonicalBinding.name}/${canonicalBinding.id}`);
+    return import_compiler38.types.stringLiteral(`${canonicalBinding.name}/${canonicalBinding.id}`);
   }
-  return import_compiler35.types.stringLiteral(canonicalBinding.name);
+  return import_compiler38.types.stringLiteral(canonicalBinding.name);
 }
 function getScopeAccessor(binding, encoded, includeId) {
   const canonicalBinding = getCanonicalBinding(binding);
@@ -8910,7 +9098,7 @@ function getSectionInstancesAccessor(section) {
 }
 function getSectionInstancesAccessorLiteral(section) {
   const accessor = getSectionInstancesAccessor(section);
-  return accessor ? typeof accessor === "number" ? import_compiler35.types.numericLiteral(accessor) : import_compiler35.types.stringLiteral(accessor) : void 0;
+  return accessor ? typeof accessor === "number" ? import_compiler38.types.numericLiteral(accessor) : import_compiler38.types.stringLiteral(accessor) : void 0;
 }
 function getReadReplacement(node) {
   const { extra } = node;
@@ -8923,13 +9111,13 @@ function getReadReplacement(node) {
       if (isOutputDOM()) {
         if (readBinding.type === 0 /* dom */) {
           if (!extra[kIsInvoked] && readBinding.section.domGetterBindings.has(readBinding)) {
-            replacement = import_compiler35.types.callExpression(
+            replacement = import_compiler38.types.callExpression(
               getBindingGetterIdentifier(readBinding),
               [getScopeExpression(extra.section, readBinding.section)]
             );
           }
         } else if (readBinding.type === 6 /* hoist */ && extra[kIsInvoked]) {
-          replacement = import_compiler35.types.callExpression(
+          replacement = import_compiler38.types.callExpression(
             getBindingGetterIdentifier(readBinding),
             [getScopeExpression(extra.section, readBinding.section)]
           );
@@ -8938,7 +9126,7 @@ function getReadReplacement(node) {
         }
       } else {
         if (node.type !== "Identifier") {
-          replacement = import_compiler35.types.identifier(readBinding.name);
+          replacement = import_compiler38.types.identifier(readBinding.name);
         } else if (readBinding.name !== node.name && readBinding.type !== 0 /* dom */ && (readBinding.type !== 6 /* hoist */ || !extra[kIsInvoked])) {
           node.name = readBinding.name;
         }
@@ -8948,7 +9136,7 @@ function getReadReplacement(node) {
       let curNode = node;
       let curBinding = read.binding;
       let replaceMember;
-      replacement = isOutputDOM() ? createScopeReadExpression(read.binding, extra.section) : import_compiler35.types.identifier(read.binding.name);
+      replacement = isOutputDOM() ? createScopeReadExpression(read.binding, extra.section) : import_compiler38.types.identifier(read.binding.name);
       while (props.length && (curNode.type === "MemberExpression" || curNode.type === "OptionalMemberExpression")) {
         const prop = props.pop();
         const memberProp = getMemberExpressionPropString(curNode);
@@ -9164,7 +9352,7 @@ function getAllSerializeReasonsForExtra(extra) {
   let reason = serializeReasonCache.get(extra);
   if (reason === false) return;
   if (reason === void 0) {
-    if (extra === (0, import_babel_utils25.getProgram)().node.extra?.returnValueExpr) {
+    if (extra === (0, import_babel_utils26.getProgram)().node.extra?.returnValueExpr) {
       reason = true;
     } else {
       forEach(extra.downstream, (binding) => {
@@ -9226,10 +9414,10 @@ function addNumericPropertiesUntil(props, len) {
 var kDOMBinding = Symbol("await tag dom binding");
 var await_default = {
   analyze(tag) {
-    (0, import_babel_utils26.assertNoVar)(tag);
-    (0, import_babel_utils26.assertNoArgs)(tag);
+    (0, import_babel_utils27.assertNoVar)(tag);
+    (0, import_babel_utils27.assertNoArgs)(tag);
     assertNoSpreadAttrs(tag);
-    (0, import_babel_utils26.assertNoAttributeTags)(tag);
+    (0, import_babel_utils27.assertNoAttributeTags)(tag);
     const { node } = tag;
     const tagBody = tag.get("body");
     const section = getOrCreateSection(tag);
@@ -9241,7 +9429,7 @@ var await_default = {
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) requires a [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
-    if (node.attributes.length > 1 || !import_compiler36.types.isMarkoAttribute(valueAttr) || valueAttr.name !== "value") {
+    if (node.attributes.length > 1 || !import_compiler39.types.isMarkoAttribute(valueAttr) || valueAttr.name !== "value") {
       throw tag.get("name").buildCodeFrameError(
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
@@ -9251,7 +9439,7 @@ var await_default = {
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) requires [content](https://markojs.com/docs/reference/language#tag-content)."
       );
     }
-    if (node.body.params.length && (node.body.params.length > 1 || import_compiler36.types.isSpreadElement(node.body.params[0]))) {
+    if (node.body.params.length && (node.body.params.length > 1 || import_compiler39.types.isSpreadElement(node.body.params[0]))) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<await>` tag](https://markojs.com/docs/reference/core-tag#await) only supports a single parameter."
       );
@@ -9288,13 +9476,13 @@ var await_default = {
         flushInto(tag);
         writeHTMLResumeStatements(tagBody);
         tag.replaceWith(
-          import_compiler36.types.expressionStatement(
+          import_compiler39.types.expressionStatement(
             callRuntime(
               "_await",
               getScopeIdIdentifier(section),
               getScopeAccessorLiteral(nodeRef),
               valueAttr.value,
-              import_compiler36.types.arrowFunctionExpression(
+              import_compiler39.types.arrowFunctionExpression(
                 node.body.params,
                 toFirstExpressionOrBlock(node.body.body)
               ),
@@ -9328,9 +9516,9 @@ var await_default = {
           const branchRenderArgs = getBranchRendererArgs(bodySection);
           const branchParams = branchRenderArgs.pop();
           (signal.prependStatements ||= []).push(
-            import_compiler36.types.variableDeclaration("const", [
-              import_compiler36.types.variableDeclarator(
-                import_compiler36.types.identifier(bodySection.name),
+            import_compiler39.types.variableDeclaration("const", [
+              import_compiler39.types.variableDeclarator(
+                import_compiler39.types.identifier(bodySection.name),
                 callRuntime(
                   "_await_content",
                   getScopeAccessorLiteral(nodeRef, true),
@@ -9349,8 +9537,8 @@ var await_default = {
           "render",
           section,
           void 0,
-          import_compiler36.types.expressionStatement(
-            import_compiler36.types.callExpression(import_compiler36.types.identifier(bodySection.name), [scopeIdentifier])
+          import_compiler39.types.expressionStatement(
+            import_compiler39.types.callExpression(import_compiler39.types.identifier(bodySection.name), [scopeIdentifier])
           )
         );
         addValue(
@@ -9374,8 +9562,8 @@ var await_default = {
 };
 
 // src/translator/core/client.ts
-var import_compiler37 = require("@marko/compiler");
-var import_babel_utils27 = require("@marko/compiler/babel-utils");
+var import_compiler40 = require("@marko/compiler");
+var import_babel_utils28 = require("@marko/compiler/babel-utils");
 var client_default = {
   parse(tag) {
     const {
@@ -9385,11 +9573,11 @@ var client_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^client\s*/, "");
     const start = node.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils27.parseStatements)(file, code, start, start + code.length);
-    if (body.length === 1 && import_compiler37.types.isBlockStatement(body[0])) {
+    let body = (0, import_babel_utils28.parseStatements)(file, code, start, start + code.length);
+    if (body.length === 1 && import_compiler40.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
-    tag.replaceWith(import_compiler37.types.markoScriptlet(body, true, "client"));
+    tag.replaceWith(import_compiler40.types.markoScriptlet(body, true, "client"));
   },
   parseOptions: {
     statement: true,
@@ -9405,12 +9593,12 @@ var client_default = {
 };
 
 // src/translator/core/const.ts
-var import_compiler38 = require("@marko/compiler");
-var import_babel_utils28 = require("@marko/compiler/babel-utils");
+var import_compiler41 = require("@marko/compiler");
+var import_babel_utils29 = require("@marko/compiler/babel-utils");
 var const_default = {
   analyze(tag) {
-    (0, import_babel_utils28.assertNoArgs)(tag);
-    (0, import_babel_utils28.assertNoParams)(tag);
+    (0, import_babel_utils29.assertNoArgs)(tag);
+    (0, import_babel_utils29.assertNoParams)(tag);
     assertNoBodyContent(tag);
     const { node } = tag;
     const [valueAttr] = node.attributes;
@@ -9424,13 +9612,13 @@ var const_default = {
         "The [`<const>` tag](https://markojs.com/docs/reference/core-tag#const) requires a [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
-    if (node.attributes.length > 1 || !import_compiler38.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value") {
+    if (node.attributes.length > 1 || !import_compiler41.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value") {
       throw tag.get("name").buildCodeFrameError(
         "The [`<const>` tag](https://markojs.com/docs/reference/core-tag#const) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
     }
     const valueExtra = evaluate(valueAttr.value);
-    const upstreamAlias = import_compiler38.types.isIdentifier(valueAttr.value) ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding : void 0;
+    const upstreamAlias = import_compiler41.types.isIdentifier(valueAttr.value) ? tag.scope.getBinding(valueAttr.value.name)?.identifier.extra?.binding : void 0;
     if (upstreamAlias) {
       valueExtra.pruned = true;
     }
@@ -9486,16 +9674,16 @@ var const_default = {
 };
 
 // src/translator/core/debug.ts
-var import_compiler39 = require("@marko/compiler");
-var import_babel_utils29 = require("@marko/compiler/babel-utils");
+var import_compiler42 = require("@marko/compiler");
+var import_babel_utils30 = require("@marko/compiler/babel-utils");
 var debug_default = {
   analyze(tag) {
     const [valueAttr] = tag.node.attributes;
-    (0, import_babel_utils29.assertNoVar)(tag);
-    (0, import_babel_utils29.assertNoArgs)(tag);
-    (0, import_babel_utils29.assertNoParams)(tag);
+    (0, import_babel_utils30.assertNoVar)(tag);
+    (0, import_babel_utils30.assertNoArgs)(tag);
+    (0, import_babel_utils30.assertNoParams)(tag);
     assertNoBodyContent(tag);
-    if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler39.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
+    if (tag.node.attributes.length > 1 || tag.node.attributes.length === 1 && (!import_compiler42.types.isMarkoAttribute(valueAttr) || !valueAttr.default && valueAttr.name !== "value")) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<debug>` tag](https://markojs.com/docs/reference/core-tag#debug) only supports the [`value=` attribute](https://markojs.com/docs/reference/language#shorthand-value)."
       );
@@ -9506,7 +9694,7 @@ var debug_default = {
       const section = getSection(tag);
       const [valueAttr] = tag.node.attributes;
       const referencedBindings = valueAttr?.value.extra?.referencedBindings;
-      const statement = withPreviousLocation(import_compiler39.types.debuggerStatement(), tag.node);
+      const statement = withPreviousLocation(import_compiler42.types.debuggerStatement(), tag.node);
       if (isOutputHTML()) {
         tag.insertBefore(statement);
       } else {
@@ -9529,11 +9717,11 @@ var debug_default = {
 };
 
 // src/translator/core/define.ts
-var import_compiler40 = require("@marko/compiler");
-var import_babel_utils30 = require("@marko/compiler/babel-utils");
+var import_compiler43 = require("@marko/compiler");
+var import_babel_utils31 = require("@marko/compiler/babel-utils");
 var define_default = {
   analyze(tag) {
-    (0, import_babel_utils30.assertNoArgs)(tag);
+    (0, import_babel_utils31.assertNoArgs)(tag);
     if (!tag.node.var) {
       throw tag.get("name").buildCodeFrameError(
         "The [`<define>` tag](https://markojs.com/docs/reference/core-tag#define) requires a [tag variable](https://markojs.com/docs/reference/language#tag-variables)."
@@ -9549,7 +9737,7 @@ var define_default = {
     trackParamsReferences(tagBody, 3 /* param */);
     setTagDownstream(tag, varBinding);
     if (bodySection) {
-      if (import_compiler40.types.isIdentifier(tag.node.var)) {
+      if (import_compiler43.types.isIdentifier(tag.node.var)) {
         const babelBinding = tag.scope.getBinding(tag.node.var.name);
         let allDirectReferences = true;
         for (const ref of babelBinding.referencePaths) {
@@ -9598,7 +9786,7 @@ var define_default = {
         tag.insertBefore(translatedAttrs.statements);
         translateVar(tag, propsToExpression(translatedAttrs.properties));
       } else {
-        if (import_compiler40.types.isIdentifier(node.var)) {
+        if (import_compiler43.types.isIdentifier(node.var)) {
           const babelBinding = tag.scope.getBinding(node.var.name);
           let hasDirectReferences = false;
           let allDirectReferences = true;
@@ -9653,24 +9841,24 @@ var define_default = {
 };
 
 // src/translator/core/effect.ts
-var import_compiler41 = require("@marko/compiler");
-var import_babel_utils31 = require("@marko/compiler/babel-utils");
+var import_compiler44 = require("@marko/compiler");
+var import_babel_utils32 = require("@marko/compiler/babel-utils");
 var effect_default = {
   migrate: [
     (tag) => {
-      (0, import_babel_utils31.assertNoArgs)(tag);
-      (0, import_babel_utils31.assertNoParams)(tag);
+      (0, import_babel_utils32.assertNoArgs)(tag);
+      (0, import_babel_utils32.assertNoParams)(tag);
       assertNoBodyContent(tag);
-      (0, import_babel_utils31.assertNoAttributeTags)(tag);
+      (0, import_babel_utils32.assertNoAttributeTags)(tag);
       assertNoSpreadAttrs(tag);
-      (0, import_babel_utils31.assertAllowedAttributes)(tag, ["value"]);
-      (0, import_babel_utils31.diagnosticDeprecate)(tag, {
+      (0, import_babel_utils32.assertAllowedAttributes)(tag, ["value"]);
+      (0, import_babel_utils32.diagnosticDeprecate)(tag, {
         label: "The 'effect' tag has been replaced by the 'script' tag.",
         fix() {
           const { node } = tag;
           tag.replaceWith(
-            import_compiler41.types.markoTag(
-              withPreviousLocation(import_compiler41.types.stringLiteral("script"), node.name),
+            import_compiler44.types.markoTag(
+              withPreviousLocation(import_compiler44.types.stringLiteral("script"), node.name),
               node.attributes,
               node.body,
               node.arguments,
@@ -9687,12 +9875,12 @@ var effect_default = {
 };
 
 // src/translator/core/export.ts
-var import_babel_utils32 = require("@marko/compiler/babel-utils");
+var import_babel_utils33 = require("@marko/compiler/babel-utils");
 var export_default = {
   parse(tag) {
     const { node } = tag;
     tag.replaceWith(
-      (0, import_babel_utils32.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
+      (0, import_babel_utils33.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
     );
   },
   parseOptions: {
@@ -9707,55 +9895,18 @@ var export_default = {
 };
 
 // src/translator/core/html-comment.ts
-var import_compiler43 = require("@marko/compiler");
-var import_babel_utils33 = require("@marko/compiler/babel-utils");
-
-// src/translator/util/body-to-text-literal.ts
-var import_compiler42 = require("@marko/compiler");
-function bodyToTextLiteral(body) {
-  const templateQuasis = [];
-  const templateExpressions = [];
-  let currentQuasi = "";
-  let placeholderExtra;
-  for (const child of body.body) {
-    if (import_compiler42.types.isMarkoText(child)) {
-      currentQuasi += child.value;
-    } else if (import_compiler42.types.isMarkoPlaceholder(child)) {
-      placeholderExtra ||= child.value.extra;
-      templateQuasis.push(templateElement(currentQuasi, false));
-      templateExpressions.push(callRuntime("_to_text", child.value));
-      currentQuasi = "";
-    }
-  }
-  if (templateExpressions.length) {
-    templateQuasis.push(templateElement(currentQuasi, true));
-    const literal = import_compiler42.types.templateLiteral(templateQuasis, templateExpressions);
-    literal.extra = placeholderExtra;
-    return literal;
-  }
-  return import_compiler42.types.stringLiteral(currentQuasi);
-}
-function templateElement(value, tail) {
-  return import_compiler42.types.templateElement(
-    {
-      raw: value.replace(/`/g, "\\`"),
-      cooked: value
-    },
-    tail
-  );
-}
-
-// src/translator/core/html-comment.ts
+var import_compiler45 = require("@marko/compiler");
+var import_babel_utils34 = require("@marko/compiler/babel-utils");
 var kNodeBinding = Symbol("comment tag binding");
 var html_comment_default = {
   analyze(tag) {
-    (0, import_babel_utils33.assertNoArgs)(tag);
-    (0, import_babel_utils33.assertNoParams)(tag);
-    (0, import_babel_utils33.assertNoAttributes)(tag);
+    (0, import_babel_utils34.assertNoArgs)(tag);
+    (0, import_babel_utils34.assertNoParams)(tag);
+    (0, import_babel_utils34.assertNoAttributes)(tag);
     const tagVar = tag.node.var;
     let needsBinding = false;
     if (tagVar) {
-      if (!import_compiler43.types.isIdentifier(tagVar)) {
+      if (!import_compiler45.types.isIdentifier(tagVar)) {
         throw tag.get("var").buildCodeFrameError(
           "The [`<html-comment>` tag](https://markojs.com/docs/reference/core-tag#html-comment) tag variable cannot be destructured."
         );
@@ -9772,693 +9923,44 @@ var html_comment_default = {
           "Invalid child. Only text is allowed inside an html comment."
         );
       }
-    }
-    if (needsBinding) {
-      const tagSection = getOrCreateSection(tag);
-      const tagExtra = mergeReferences(tagSection, tag.node, referenceNodes);
-      const nodeBinding = tagExtra[kNodeBinding] = createBinding(
-        "#comment",
-        0 /* dom */,
-        tagSection
-      );
-      trackDomVarReferences(tag, nodeBinding);
-      addSerializeExpr(tagSection, !!tagVar || tagExtra, nodeBinding);
-    }
-    tag.skip();
-  },
-  translate: {
-    enter(tag) {
-      const tagExtra = tag.node.extra;
-      const nodeBinding = tagExtra[kNodeBinding];
-      if (isOutputHTML()) {
-        translateDomVar(tag, nodeBinding);
-      }
-      if (nodeBinding) {
-        visit(tag, 32 /* Get */);
-      }
-      enter2(tag);
-      writeTo(tag)`<!--`;
-    },
-    exit(tag) {
-      const tagSection = getSection(tag);
-      const tagExtra = tag.node.extra;
-      const nodeBinding = tagExtra[kNodeBinding];
-      const write = writeTo(tag);
-      if (isOutputHTML()) {
-        for (const child of tag.node.body.body) {
-          if (import_compiler43.types.isMarkoText(child)) {
-            write`${child.value}`;
-          } else if (import_compiler43.types.isMarkoPlaceholder(child)) {
-            write`${callRuntime("_to_text", child.value)}`;
-          }
-        }
-      } else {
-        const textLiteral = bodyToTextLiteral(tag.node.body);
-        if (import_compiler43.types.isStringLiteral(textLiteral)) {
-          write`${textLiteral}`;
-        } else {
-          addStatement(
-            "render",
-            getSection(tag),
-            tagExtra.referencedBindings,
-            import_compiler43.types.expressionStatement(
-              callRuntime(
-                "_text",
-                createScopeReadExpression(nodeBinding),
-                textLiteral
-              )
-            )
-          );
-        }
-      }
-      exit2(tag);
-      write`-->`;
-      if (nodeBinding) {
-        markNode(
-          tag,
-          nodeBinding,
-          getSerializeReason(tagSection, nodeBinding)
-        );
-      }
-      tag.remove();
-    }
-  },
-  parseOptions: {
-    text: true
-  },
-  attributes: {},
-  autocomplete: [
-    {
-      description: "Use to create an html comment that is not stripped from the output.",
-      descriptionMoreURL: "https://markojs.com/docs/reference/core-tag#html-comment"
-    }
-  ]
-};
-
-// src/translator/core/html-script.ts
-var import_compiler44 = require("@marko/compiler");
-var import_babel_utils34 = require("@marko/compiler/babel-utils");
-var kNodeBinding2 = Symbol("script tag node binding");
-var html_script_default = {
-  analyze(tag) {
-    (0, import_babel_utils34.assertNoArgs)(tag);
-    (0, import_babel_utils34.assertNoParams)(tag);
-    const { node } = tag;
-    if (node.var && !import_compiler44.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_compiler44.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_compiler44.types.isMarkoSpreadAttribute(attr)) {
-        valueExtra.isEffect = true;
-        hasEventHandlers = true;
-        hasDynamicAttributes = true;
-      }
-      if (spreadReferenceNodes) {
-        spreadReferenceNodes.push(attr.value);
-      } else if (import_compiler44.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_compiler44.types.isMarkoPlaceholder(child)) {
-        bodyPlaceholderNodes.push(child.value);
-        hasBodyPlaceholders = true;
-      } else if (!import_compiler44.types.isMarkoText(child)) {
-        throw tag.hub.buildError(
-          child,
-          "Invalid child. Only text is allowed inside an html-script."
-        );
-      }
-    }
-    if (node.var || hasEventHandlers || hasDynamicAttributes || hasBodyPlaceholders) {
-      const tagExtra = node.extra ??= {};
-      const tagSection = getOrCreateSection(tag);
-      const nodeBinding = tagExtra[kNodeBinding2] = createBinding(
-        "#script",
-        0 /* dom */,
-        tagSection
-      );
-      if (hasEventHandlers) {
-        (0, import_babel_utils34.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[kNodeBinding2];
-      const isHTML = isOutputHTML();
-      const write = writeTo(tag);
-      const tagSection = getSection(tag);
-      if (isHTML) {
-        translateDomVar(tag, nodeBinding);
-      }
-      if (nodeBinding) {
-        visit(tag, 32 /* Get */);
-      }
-      write`<script`;
-      const usedAttrs = getUsedAttrs2(tag.node, isHTML);
-      const { hasNonce, staticAttrs, skipExpression, spreadExpression } = usedAttrs;
-      if (isHTML && !hasNonce && !spreadExpression) {
-        write`${callRuntime("_attr_nonce")}`;
-      }
-      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_compiler44.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_compiler44.types.stringLiteral(name2), value)}`;
-              }
-            } else if (isEventHandler(name2)) {
-              addStatement(
-                "effect",
-                tagSection,
-                valueReferences,
-                import_compiler44.types.expressionStatement(
-                  callRuntime(
-                    "_on",
-                    createScopeReadExpression(nodeBinding),
-                    import_compiler44.types.stringLiteral(getEventHandlerName(name2)),
-                    value
-                  )
-                )
-              );
-            } else {
-              addStatement(
-                "render",
-                tagSection,
-                valueReferences,
-                import_compiler44.types.expressionStatement(
-                  callRuntime(
-                    "_attr",
-                    createScopeReadExpression(nodeBinding),
-                    import_compiler44.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_compiler44.types.stringLiteral("script"))}`;
-          } else {
-            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler44.types.stringLiteral("script"))}`;
-          }
-        } else {
-          if (skipExpression) {
-            addStatement(
-              "render",
-              tagSection,
-              tagExtra.referencedBindings,
-              import_compiler44.types.expressionStatement(
-                callRuntime(
-                  "_attrs_partial",
-                  scopeIdentifier,
-                  visitAccessor,
-                  spreadExpression,
-                  skipExpression
-                )
-              )
-            );
-          } else {
-            addStatement(
-              "render",
-              tagSection,
-              tagExtra.referencedBindings,
-              import_compiler44.types.expressionStatement(
-                callRuntime(
-                  "_attrs",
-                  scopeIdentifier,
-                  visitAccessor,
-                  spreadExpression
-                )
-              )
-            );
-          }
-          addStatement(
-            "effect",
-            tagSection,
-            tagExtra.referencedBindings,
-            import_compiler44.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[kNodeBinding2];
-      const write = writeTo(tag);
-      if (isOutputHTML()) {
-        for (const child of tag.node.body.body) {
-          if (import_compiler44.types.isMarkoText(child)) {
-            write`${child.value}`;
-          } else if (import_compiler44.types.isMarkoPlaceholder(child)) {
-            write`${callRuntime("_escape_script", child.value)}`;
-          }
-        }
-      } else {
-        const textLiteral = bodyToTextLiteral(tag.node.body);
-        if (import_compiler44.types.isStringLiteral(textLiteral)) {
-          write`${textLiteral}`;
-        } else {
-          addStatement(
-            "render",
-            getSection(tag),
-            textLiteral.extra?.referencedBindings,
-            import_compiler44.types.expressionStatement(
-              callRuntime(
-                "_text_content",
-                createScopeReadExpression(nodeBinding),
-                textLiteral
-              )
-            )
-          );
-        }
-      }
-      write`</script>`;
-      if (nodeBinding) {
-        markNode(
-          tag,
-          nodeBinding,
-          getSerializeReason(tagSection, nodeBinding)
-        );
-      }
-      exit2(tag);
-      tag.remove();
-    }
-  },
-  "@async": "#html-async",
-  "@crossorigin": "#html-crossorigin",
-  "@defer": "#html-defer",
-  "@integrity": "#html-integrity",
-  "@nomodule": "#html-nomodule",
-  "@nonce": "#html-nonce",
-  "@referrerpolicy": "#html-referrerpolicy",
-  "@src": "#html-src",
-  "@type": "#html-type",
-  "attribute-groups": ["html-attributes"],
-  parseOptions: {
-    text: true,
-    preserveWhitespace: true
-  },
-  autocomplete: [
-    {
-      description: "Use instead of `<script>` to render a native tag directly, without processing by Marko.",
-      descriptionMoreURL: "https://markojs.com/docs/reference/core-tag#html-script--html-style"
-    }
-  ]
-};
-function getUsedAttrs2(tag, injectNonce) {
-  const seen = {};
-  const { attributes } = tag;
-  const maybeStaticAttrs = /* @__PURE__ */ new Set();
-  let spreadExpression;
-  let skipExpression;
-  let spreadProps;
-  let skipProps;
-  let hasNonce = false;
-  for (let i = attributes.length; i--; ) {
-    const attr = attributes[i];
-    const { value } = attr;
-    if (import_compiler44.types.isMarkoSpreadAttribute(attr)) {
-      if (!spreadProps) {
-        spreadProps = [];
-      }
-      spreadProps.push(import_compiler44.types.spreadElement(value));
-    } else if (!seen[attr.name]) {
-      seen[attr.name] = attr;
-      if (attr.name === "nonce") {
-        hasNonce = true;
-      }
-      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_compiler44.types.numericLiteral(1)));
-    }
-    if (skipProps) {
-      skipExpression = import_compiler44.types.objectExpression(skipProps);
-    }
-    if (injectNonce && !hasNonce) {
-      spreadProps.unshift(
-        import_compiler44.types.objectProperty(
-          import_compiler44.types.identifier("nonce"),
-          import_compiler44.types.memberExpression(callRuntime("$global"), import_compiler44.types.identifier("cspNonce"))
-        )
-      );
-    }
-    spreadExpression = propsToExpression(spreadProps);
-  }
-  return {
-    hasNonce,
-    staticAttrs,
-    spreadExpression,
-    skipExpression
-  };
-}
-
-// src/translator/core/html-style.ts
-var import_compiler45 = require("@marko/compiler");
-var import_babel_utils35 = require("@marko/compiler/babel-utils");
-var kNodeBinding3 = Symbol("style tag node binding");
-var html_style_default = {
-  analyze(tag) {
-    (0, import_babel_utils35.assertNoArgs)(tag);
-    (0, import_babel_utils35.assertNoParams)(tag);
-    const { node } = tag;
-    if (node.var && !import_compiler45.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_compiler45.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_compiler45.types.isMarkoSpreadAttribute(attr)) {
-        valueExtra.isEffect = true;
-        hasEventHandlers = true;
-        hasDynamicAttributes = true;
-      }
-      if (spreadReferenceNodes) {
-        spreadReferenceNodes.push(attr.value);
-      } else if (import_compiler45.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_compiler45.types.isMarkoPlaceholder(child)) {
-        bodyPlaceholderNodes.push(child.value);
-        hasBodyPlaceholders = true;
-      } else if (!import_compiler45.types.isMarkoText(child)) {
-        throw tag.hub.buildError(
-          child,
-          "Invalid child. Only text is allowed inside an html-style."
-        );
-      }
-    }
-    if (node.var || hasEventHandlers || hasDynamicAttributes || hasBodyPlaceholders) {
-      const tagExtra = node.extra ??= {};
-      const tagSection = getOrCreateSection(tag);
-      const nodeBinding = tagExtra[kNodeBinding3] = createBinding(
-        "#style",
-        0 /* dom */,
-        tagSection
-      );
-      if (hasEventHandlers) {
-        (0, import_babel_utils35.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[kNodeBinding3];
-      const isHTML = isOutputHTML();
-      const write = writeTo(tag);
-      const tagSection = getSection(tag);
-      if (isHTML) {
-        translateDomVar(tag, nodeBinding);
-      }
-      if (nodeBinding) {
-        visit(tag, 32 /* Get */);
-      }
-      write`<style`;
-      const usedAttrs = getUsedAttrs3(tag.node, isHTML);
-      const { hasNonce, staticAttrs, skipExpression, spreadExpression } = usedAttrs;
-      if (isHTML && !hasNonce && !spreadExpression) {
-        write`${callRuntime("_attr_nonce")}`;
-      }
-      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_compiler45.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_compiler45.types.stringLiteral(name2), value)}`;
-              }
-            } else if (isEventHandler(name2)) {
-              addStatement(
-                "effect",
-                tagSection,
-                valueReferences,
-                import_compiler45.types.expressionStatement(
-                  callRuntime(
-                    "_on",
-                    createScopeReadExpression(nodeBinding),
-                    import_compiler45.types.stringLiteral(getEventHandlerName(name2)),
-                    value
-                  )
-                )
-              );
-            } else {
-              addStatement(
-                "render",
-                tagSection,
-                valueReferences,
-                import_compiler45.types.expressionStatement(
-                  callRuntime(
-                    "_attr",
-                    createScopeReadExpression(nodeBinding),
-                    import_compiler45.types.stringLiteral(name2),
-                    value
-                  )
-                )
-              );
-            }
-            break;
-        }
-      }
-      if (spreadExpression) {
-        const visitAccessor = nodeBinding && getScopeAccessorLiteral(nodeBinding);
-        if (isHTML) {
-          addHTMLEffectCall(tagSection, tagExtra.referencedBindings);
-          if (skipExpression) {
-            write`${callRuntime("_attrs_partial", spreadExpression, skipExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler45.types.stringLiteral("style"))}`;
-          } else {
-            write`${callRuntime("_attrs", spreadExpression, visitAccessor, getScopeIdIdentifier(tagSection), import_compiler45.types.stringLiteral("style"))}`;
-          }
-        } else {
-          if (skipExpression) {
-            addStatement(
-              "render",
-              tagSection,
-              tagExtra.referencedBindings,
-              import_compiler45.types.expressionStatement(
-                callRuntime(
-                  "_attrs_partial",
-                  scopeIdentifier,
-                  visitAccessor,
-                  spreadExpression,
-                  skipExpression
-                )
-              )
-            );
-          } else {
-            addStatement(
-              "render",
-              tagSection,
-              tagExtra.referencedBindings,
-              import_compiler45.types.expressionStatement(
-                callRuntime(
-                  "_attrs",
-                  scopeIdentifier,
-                  visitAccessor,
-                  spreadExpression
-                )
-              )
-            );
-          }
-          addStatement(
-            "effect",
-            tagSection,
-            tagExtra.referencedBindings,
-            import_compiler45.types.expressionStatement(
-              callRuntime("_attrs_script", scopeIdentifier, visitAccessor)
-            ),
-            false
-          );
-        }
+    }
+    if (needsBinding) {
+      const tagSection = getOrCreateSection(tag);
+      const tagExtra = mergeReferences(tagSection, tag.node, referenceNodes);
+      const nodeBinding = tagExtra[kNodeBinding] = createBinding(
+        "#comment",
+        0 /* dom */,
+        tagSection
+      );
+      trackDomVarReferences(tag, nodeBinding);
+      addSerializeExpr(tagSection, !!tagVar || tagExtra, nodeBinding);
+    }
+    tag.skip();
+  },
+  translate: {
+    enter(tag) {
+      const tagExtra = tag.node.extra;
+      const nodeBinding = tagExtra[kNodeBinding];
+      if (isOutputHTML()) {
+        translateDomVar(tag, nodeBinding);
+      }
+      if (nodeBinding) {
+        visit(tag, 32 /* Get */);
       }
-      write`>`;
       enter2(tag);
+      writeTo(tag)`<!--`;
     },
     exit(tag) {
       const tagSection = getSection(tag);
       const tagExtra = tag.node.extra;
-      const nodeBinding = tagExtra[kNodeBinding3];
+      const nodeBinding = tagExtra[kNodeBinding];
       const write = writeTo(tag);
       if (isOutputHTML()) {
         for (const child of tag.node.body.body) {
           if (import_compiler45.types.isMarkoText(child)) {
             write`${child.value}`;
           } else if (import_compiler45.types.isMarkoPlaceholder(child)) {
-            write`${callRuntime("_escape_style", child.value)}`;
+            write`${callRuntime("_escape_text", child.value)}`;
           }
         }
       } else {
@@ -10469,10 +9971,10 @@ var html_style_default = {
           addStatement(
             "render",
             getSection(tag),
-            textLiteral.extra?.referencedBindings,
+            tagExtra.referencedBindings,
             import_compiler45.types.expressionStatement(
               callRuntime(
-                "_text_content",
+                "_text",
                 createScopeReadExpression(nodeBinding),
                 textLiteral
               )
@@ -10480,7 +9982,8 @@ var html_style_default = {
           );
         }
       }
-      write`</style>`;
+      exit2(tag);
+      write`-->`;
       if (nodeBinding) {
         markNode(
           tag,
@@ -10488,91 +9991,62 @@ var html_style_default = {
           getSerializeReason(tagSection, nodeBinding)
         );
       }
-      exit2(tag);
       tag.remove();
     }
   },
-  "@disabled": "#html-disabled",
-  "@media": "#html-media",
-  "@nonce": "#html-nonce",
-  "@type": "#html-type",
-  "attribute-groups": ["html-attributes"],
+  parseOptions: {
+    text: true
+  },
+  types: runtime_info_default.name + "/tags/html-comment.d.marko",
+  autocomplete: [
+    {
+      description: "Use to create an html comment that is not stripped from the output.",
+      descriptionMoreURL: "https://markojs.com/docs/reference/core-tag#html-comment"
+    }
+  ]
+};
+
+// src/translator/core/html-script.ts
+var html_script_default = {
+  types: runtime_info_default.name + "/tags/html-script.d.marko",
+  html: true,
   parseOptions: {
     text: true,
     preserveWhitespace: true
   },
   autocomplete: [
     {
-      description: "Use instead of `<style>` to render a native tag directly, without processing by Marko.",
+      description: "Use instead of `<script>` to render a native tag directly, without processing by Marko.",
       descriptionMoreURL: "https://markojs.com/docs/reference/core-tag#html-script--html-style"
     }
   ]
 };
-function getUsedAttrs3(tag, injectNonce) {
-  const seen = {};
-  const { attributes } = tag;
-  const maybeStaticAttrs = /* @__PURE__ */ new Set();
-  let spreadExpression;
-  let skipExpression;
-  let spreadProps;
-  let skipProps;
-  let hasNonce = false;
-  for (let i = attributes.length; i--; ) {
-    const attr = attributes[i];
-    const { value } = attr;
-    if (import_compiler45.types.isMarkoSpreadAttribute(attr)) {
-      if (!spreadProps) {
-        spreadProps = [];
-      }
-      spreadProps.push(import_compiler45.types.spreadElement(value));
-    } else if (!seen[attr.name]) {
-      seen[attr.name] = attr;
-      if (attr.name === "nonce") {
-        hasNonce = true;
-      }
-      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_compiler45.types.numericLiteral(1)));
-    }
-    if (skipProps) {
-      skipExpression = import_compiler45.types.objectExpression(skipProps);
-    }
-    if (injectNonce && !hasNonce) {
-      spreadProps.unshift(
-        import_compiler45.types.objectProperty(
-          import_compiler45.types.identifier("nonce"),
-          import_compiler45.types.memberExpression(callRuntime("$global"), import_compiler45.types.identifier("cspNonce"))
-        )
-      );
+
+// src/translator/core/html-style.ts
+var html_style_default = {
+  types: runtime_info_default.name + "/tags/html-style.d.marko",
+  html: true,
+  parseOptions: {
+    text: true,
+    preserveWhitespace: true
+  },
+  autocomplete: [
+    {
+      description: "Use instead of `<style>` to render a native tag directly, without processing by Marko.",
+      descriptionMoreURL: "https://markojs.com/docs/reference/core-tag#html-script--html-style"
     }
-    spreadExpression = propsToExpression(spreadProps);
-  }
-  return {
-    hasNonce,
-    staticAttrs,
-    spreadExpression,
-    skipExpression
-  };
-}
+  ]
+};
 
 // src/translator/core/id.ts
 var import_compiler46 = require("@marko/compiler");
-var import_babel_utils36 = require("@marko/compiler/babel-utils");
+var import_babel_utils35 = require("@marko/compiler/babel-utils");
 var id_default = {
   analyze(tag) {
-    (0, import_babel_utils36.assertNoArgs)(tag);
-    (0, import_babel_utils36.assertNoParams)(tag);
+    (0, import_babel_utils35.assertNoArgs)(tag);
+    (0, import_babel_utils35.assertNoParams)(tag);
     assertNoBodyContent(tag);
-    (0, import_babel_utils36.assertNoAttributeTags)(tag);
+    (0, import_babel_utils35.assertNoAttributeTags)(tag);
     const { node } = tag;
     const [valueAttr] = node.attributes;
     if (!node.var) {
@@ -10644,7 +10118,7 @@ var id_default = {
 
 // src/translator/core/if.ts
 var import_compiler48 = require("@marko/compiler");
-var import_babel_utils37 = require("@marko/compiler/babel-utils");
+var import_babel_utils36 = require("@marko/compiler/babel-utils");
 
 // src/translator/util/to-first-statement-or-block.ts
 var import_compiler47 = require("@marko/compiler");
@@ -10912,9 +10386,9 @@ var ElseTag = {
   ]
 };
 function assertValidCondition(tag) {
-  (0, import_babel_utils37.assertNoVar)(tag);
-  (0, import_babel_utils37.assertNoArgs)(tag);
-  (0, import_babel_utils37.assertNoParams)(tag);
+  (0, import_babel_utils36.assertNoVar)(tag);
+  (0, import_babel_utils36.assertNoArgs)(tag);
+  (0, import_babel_utils36.assertNoParams)(tag);
   assertHasBody(tag);
   assertNoSpreadAttrs(tag);
   switch (getTagName(tag)) {
@@ -11013,12 +10487,12 @@ function isRoot(tag) {
 }
 
 // src/translator/core/import.ts
-var import_babel_utils38 = require("@marko/compiler/babel-utils");
+var import_babel_utils37 = require("@marko/compiler/babel-utils");
 var import_default = {
   parse(tag) {
     const { node } = tag;
     tag.replaceWith(
-      (0, import_babel_utils38.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
+      (0, import_babel_utils37.parseStatements)(tag.hub.file, node.rawValue, node.start, node.end)[0]
     );
   },
   parseOptions: {
@@ -11037,7 +10511,7 @@ var import_default = {
 
 // src/translator/core/let.ts
 var import_compiler49 = require("@marko/compiler");
-var import_babel_utils39 = require("@marko/compiler/babel-utils");
+var import_babel_utils38 = require("@marko/compiler/babel-utils");
 var let_default = {
   analyze(tag) {
     const { node } = tag;
@@ -11066,8 +10540,8 @@ var let_default = {
         }
       }
     }
-    (0, import_babel_utils39.assertNoArgs)(tag);
-    (0, import_babel_utils39.assertNoParams)(tag);
+    (0, import_babel_utils38.assertNoArgs)(tag);
+    (0, import_babel_utils38.assertNoParams)(tag);
     assertNoBodyContent(tag);
     assertNoSpreadAttrs(tag);
     if (!tagVar) {
@@ -11080,7 +10554,7 @@ var let_default = {
         "The [`<let>` tag](https://markojs.com/docs/reference/core-tag#let) variable cannot be destructured."
       );
     }
-    if (valueChangeAttr && (0, import_babel_utils39.computeNode)(valueChangeAttr.value)?.value) {
+    if (valueChangeAttr && (0, import_babel_utils38.computeNode)(valueChangeAttr.value)?.value) {
       throw tag.get("attributes").find((attr) => attr.node === valueChangeAttr).get("value").buildCodeFrameError(
         "The [`<let>` tag](https://markojs.com/docs/reference/core-tag#let) [`valueChange=` attribute](https://markojs.com/docs/reference/core-tag#controllable-let) must be a function."
       );
@@ -11163,13 +10637,13 @@ var let_default = {
 
 // src/translator/core/lifecycle.ts
 var import_compiler50 = require("@marko/compiler");
-var import_babel_utils40 = require("@marko/compiler/babel-utils");
+var import_babel_utils39 = require("@marko/compiler/babel-utils");
 var kRef = Symbol("lifecycle attrs reference");
 var lifecycle_default = {
   analyze(tag) {
-    (0, import_babel_utils40.assertNoArgs)(tag);
-    (0, import_babel_utils40.assertNoVar)(tag);
-    (0, import_babel_utils40.assertNoParams)(tag);
+    (0, import_babel_utils39.assertNoArgs)(tag);
+    (0, import_babel_utils39.assertNoVar)(tag);
+    (0, import_babel_utils39.assertNoParams)(tag);
     assertNoBodyContent(tag);
     const { node } = tag;
     const section = getOrCreateSection(tag);
@@ -11197,7 +10671,7 @@ var lifecycle_default = {
       }
       (attr.value.extra ??= {}).isEffect = true;
     }
-    (0, import_babel_utils40.getProgram)().node.extra.isInteractive = true;
+    (0, import_babel_utils39.getProgram)().node.extra.isInteractive = true;
   },
   translate: {
     exit(tag) {
@@ -11245,13 +10719,13 @@ var lifecycle_default = {
 
 // src/translator/core/log.ts
 var import_compiler51 = require("@marko/compiler");
-var import_babel_utils41 = require("@marko/compiler/babel-utils");
+var import_babel_utils40 = require("@marko/compiler/babel-utils");
 var log_default = {
   analyze(tag) {
     const [valueAttr] = tag.node.attributes;
-    (0, import_babel_utils41.assertNoArgs)(tag);
-    (0, import_babel_utils41.assertNoVar)(tag);
-    (0, import_babel_utils41.assertNoParams)(tag);
+    (0, import_babel_utils40.assertNoArgs)(tag);
+    (0, import_babel_utils40.assertNoVar)(tag);
+    (0, import_babel_utils40.assertNoParams)(tag);
     assertNoBodyContent(tag);
     if (!valueAttr) {
       throw tag.get("name").buildCodeFrameError(
@@ -11299,7 +10773,7 @@ var log_default = {
 
 // src/translator/core/script.ts
 var import_compiler52 = require("@marko/compiler");
-var import_babel_utils42 = require("@marko/compiler/babel-utils");
+var import_babel_utils41 = require("@marko/compiler/babel-utils");
 var htmlScriptTagAlternateMsg = " For a native html [`<script>` tag](https://markojs.com/docs/reference/core-tag#script) use the `html-script` core tag instead.";
 var script_default = {
   parse(tag) {
@@ -11319,7 +10793,7 @@ var script_default = {
       }
       const start = body[0]?.start;
       const end = body[body.length - 1]?.end;
-      const bodyStatements = (0, import_babel_utils42.parseStatements)(tag.hub.file, code, start, end);
+      const bodyStatements = (0, import_babel_utils41.parseStatements)(tag.hub.file, code, start, end);
       if (bodyStatements.length) {
         const valueFn = import_compiler52.types.arrowFunctionExpression(
           [],
@@ -11333,10 +10807,10 @@ var script_default = {
   },
   analyze(tag) {
     const { node } = tag;
-    (0, import_babel_utils42.assertNoArgs)(tag);
-    (0, import_babel_utils42.assertNoParams)(tag);
+    (0, import_babel_utils41.assertNoArgs)(tag);
+    (0, import_babel_utils41.assertNoParams)(tag);
     assertNoBodyContent(tag);
-    (0, import_babel_utils42.assertNoAttributeTags)(tag);
+    (0, import_babel_utils41.assertNoAttributeTags)(tag);
     if (node.var) {
       throw tag.hub.buildError(
         node.var,
@@ -11351,7 +10825,7 @@ var script_default = {
         }
         seenValueAttr = true;
         (attr.value.extra ??= {}).isEffect = true;
-        (0, import_babel_utils42.getProgram)().node.extra.isInteractive = true;
+        (0, import_babel_utils41.getProgram)().node.extra.isInteractive = true;
       } else {
         throw tag.hub.buildError(
           attr,
@@ -11413,7 +10887,6 @@ var script_default = {
     text: true,
     preserveWhitespace: true
   },
-  attributes: {},
   autocomplete: [
     {
       description: "Use to create a side effects.",
@@ -11442,7 +10915,7 @@ function isAwaitExpression(node) {
 
 // src/translator/core/server.ts
 var import_compiler53 = require("@marko/compiler");
-var import_babel_utils43 = require("@marko/compiler/babel-utils");
+var import_babel_utils42 = require("@marko/compiler/babel-utils");
 var server_default = {
   parse(tag) {
     const {
@@ -11452,7 +10925,7 @@ var server_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^server\s*/, "");
     const start = node.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils43.parseStatements)(file, code, start, start + code.length);
+    let body = (0, import_babel_utils42.parseStatements)(file, code, start, start + code.length);
     if (body.length === 1 && import_compiler53.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
@@ -11473,7 +10946,7 @@ var server_default = {
 
 // src/translator/core/static.ts
 var import_compiler54 = require("@marko/compiler");
-var import_babel_utils44 = require("@marko/compiler/babel-utils");
+var import_babel_utils43 = require("@marko/compiler/babel-utils");
 var static_default = {
   parse(tag) {
     const {
@@ -11483,7 +10956,7 @@ var static_default = {
     const rawValue = node.rawValue;
     const code = rawValue.replace(/^static\s*/, "");
     const start = node.start + (rawValue.length - code.length);
-    let body = (0, import_babel_utils44.parseStatements)(file, code, start, start + code.length);
+    let body = (0, import_babel_utils43.parseStatements)(file, code, start, start + code.length);
     if (body.length === 1 && import_compiler54.types.isBlockStatement(body[0])) {
       body = body[0].body;
     }
@@ -11504,16 +10977,16 @@ var static_default = {
 
 // src/translator/core/style.ts
 var import_compiler55 = require("@marko/compiler");
-var import_babel_utils45 = require("@marko/compiler/babel-utils");
+var import_babel_utils44 = require("@marko/compiler/babel-utils");
 var import_magic_string = __toESM(require("magic-string"));
 var import_path3 = __toESM(require("path"));
 var STYLE_EXT_REG = /^style((?:\.[a-zA-Z0-9$_-]+)+)?/;
 var htmlStyleTagAlternateMsg = " For a native html [`<style>` tag](https://markojs.com/docs/reference/core-tag#style) use the `html-style` core tag instead.";
 var style_default = {
   analyze(tag) {
-    (0, import_babel_utils45.assertNoArgs)(tag);
-    (0, import_babel_utils45.assertNoParams)(tag);
-    (0, import_babel_utils45.assertNoAttributeTags)(tag);
+    (0, import_babel_utils44.assertNoArgs)(tag);
+    (0, import_babel_utils44.assertNoParams)(tag);
+    (0, import_babel_utils44.assertNoAttributeTags)(tag);
     const { node } = tag;
     const ext = STYLE_EXT_REG.exec(node.rawValue || "")?.[1]?.slice(1);
     for (const attr of node.attributes) {
@@ -11552,8 +11025,8 @@ var style_default = {
     }
     const markoText = node.body.body[0];
     const { resolveVirtualDependency } = getMarkoOpts();
-    const start = (0, import_babel_utils45.getStart)(file, markoText);
-    const end = (0, import_babel_utils45.getEnd)(file, markoText);
+    const start = (0, import_babel_utils44.getStart)(file, markoText);
+    const end = (0, import_babel_utils44.getEnd)(file, markoText);
     let code = markoText.value;
     let map;
     if (resolveVirtualDependency && sourceMaps && start !== null && end !== null) {
@@ -11563,422 +11036,63 @@ var style_default = {
       map = magicString.generateMap({
         source: filename,
         includeContent: true
-      });
-      if (sourceMaps === "inline" || sourceMaps === "both") {
-        code += `
-/*# sourceMappingURL=${map.toUrl()}*/`;
-        if (sourceMaps === "inline") {
-          map = void 0;
-        }
-      }
-    }
-    const importPath = resolveVirtualDependency?.(filename, {
-      virtualPath: `./${import_path3.default.basename(filename) + ext}`,
-      code,
-      map
-    });
-    if (importPath) {
-      if (!node.var) {
-        (0, import_babel_utils45.getProgram)().node.body.push(
-          import_compiler55.types.importDeclaration([], import_compiler55.types.stringLiteral(importPath))
-        );
-      } else if (import_compiler55.types.isIdentifier(node.var)) {
-        (0, import_babel_utils45.getProgram)().node.body.push(
-          import_compiler55.types.importDeclaration(
-            [import_compiler55.types.importNamespaceSpecifier(node.var)],
-            import_compiler55.types.stringLiteral(importPath)
-          )
-        );
-      } else {
-        const varDecl = import_compiler55.types.variableDeclaration("const", [
-          import_compiler55.types.variableDeclarator(node.var, (0, import_babel_utils45.importStar)(file, importPath, "style"))
-        ]);
-        (0, import_babel_utils45.getProgram)().node.body.push(
-          isOutputDOM() ? varDecl : import_compiler55.types.markoScriptlet([varDecl], true)
-        );
-      }
-    }
-    tag.remove();
-  },
-  parseOptions: {
-    html: false,
-    text: true,
-    rawOpenTag: true,
-    preserveWhitespace: true
-  },
-  attributes: {}
-};
-
-// src/translator/core/textarea.ts
-var import_compiler56 = require("@marko/compiler");
-var textarea_default = {
-  parse(tag) {
-    if (tag.node.body.body.length) {
-      const parts = [];
-      for (const child of tag.node.body.body) {
-        if (child.type === "MarkoText" || child.type === "MarkoPlaceholder" && child.escape) {
-          parts.push(child.value);
-        } else {
-          throw tag.hub.file.hub.buildError(
-            child,
-            "Unexpected content in textarea, only text and placeholders are supported.",
-            SyntaxError
-          );
-        }
-      }
-      tag.node.attributes.push(
-        import_compiler56.types.markoAttribute(
-          "value",
-          normalizeStringExpression(parts) || buildUndefined3()
-        )
-      );
-      tag.node.body.body = [];
-    }
-  },
-  parseOptions: {
-    text: true,
-    preserveWhitespace: true
-  }
-};
-function buildUndefined3() {
-  return import_compiler56.types.unaryExpression("void", import_compiler56.types.numericLiteral(0));
-}
-
-// src/translator/core/title.ts
-var import_compiler57 = require("@marko/compiler");
-var import_babel_utils46 = require("@marko/compiler/babel-utils");
-var kNodeBinding4 = Symbol("title tag node binding");
-var title_default = {
-  analyze(tag) {
-    (0, import_babel_utils46.assertNoArgs)(tag);
-    (0, import_babel_utils46.assertNoParams)(tag);
-    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;
+      });
+      if (sourceMaps === "inline" || sourceMaps === "both") {
+        code += `
+/*# sourceMappingURL=${map.toUrl()}*/`;
+        if (sourceMaps === "inline") {
+          map = void 0;
         }
-      } 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>`."
+    const importPath = resolveVirtualDependency?.(filename, {
+      virtualPath: `./${import_path3.default.basename(filename) + ext}`,
+      code,
+      map
+    });
+    if (importPath) {
+      if (!node.var) {
+        (0, import_babel_utils44.getProgram)().node.body.push(
+          import_compiler55.types.importDeclaration([], import_compiler55.types.stringLiteral(importPath))
         );
-      }
-    }
-    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)
+      } else if (import_compiler55.types.isIdentifier(node.var)) {
+        (0, import_babel_utils44.getProgram)().node.body.push(
+          import_compiler55.types.importDeclaration(
+            [import_compiler55.types.importNamespaceSpecifier(node.var)],
+            import_compiler55.types.stringLiteral(importPath)
           )
         );
-      }
-      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)
+        const varDecl = import_compiler55.types.variableDeclaration("const", [
+          import_compiler55.types.variableDeclarator(node.var, (0, import_babel_utils44.importStar)(file, importPath, "style"))
+        ]);
+        (0, import_babel_utils44.getProgram)().node.body.push(
+          isOutputDOM() ? varDecl : import_compiler55.types.markoScriptlet([varDecl], true)
         );
       }
-      exit2(tag);
-      tag.remove();
     }
+    tag.remove();
   },
   parseOptions: {
-    text: true
-  }
+    html: false,
+    text: true,
+    rawOpenTag: true,
+    preserveWhitespace: true
+  },
+  attributes: {}
 };
-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 import_compiler56 = require("@marko/compiler");
+var import_babel_utils45 = 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);
+    (0, import_babel_utils45.assertNoVar)(tag);
+    (0, import_babel_utils45.assertNoArgs)(tag);
+    (0, import_babel_utils45.assertNoParams)(tag);
+    (0, import_babel_utils45.assertNoAttributes)(tag);
     assertNoSpreadAttrs(tag);
     analyzeAttributeTags(tag);
     const section = getOrCreateSection(tag);
@@ -12030,7 +11144,7 @@ var try_default = {
         writeHTMLResumeStatements(tagBody);
         tag.insertBefore(translatedAttrs.statements);
         tag.replaceWith(
-          import_compiler58.types.expressionStatement(
+          import_compiler56.types.expressionStatement(
             callRuntime(
               "_try",
               getScopeIdIdentifier(section),
@@ -12085,11 +11199,11 @@ var try_default = {
             translatedAttrs.statements
           );
         }
-        const program = (0, import_babel_utils47.getProgram)().node;
+        const program = (0, import_babel_utils45.getProgram)().node;
         if (!hasEnabledCatch.has(program)) {
           hasEnabledCatch.add(program);
           program.body.push(
-            import_compiler58.types.expressionStatement(callRuntime("_enable_catch"))
+            import_compiler56.types.expressionStatement(callRuntime("_enable_catch"))
           );
         }
         addValue(
@@ -12140,8 +11254,6 @@ var core_default = {
   "<server>": server_default,
   "<static>": static_default,
   "<style>": style_default,
-  "<textarea>": textarea_default,
-  "<title>": title_default,
   "<try>": try_default
 };
 
@@ -12189,13 +11301,13 @@ var document_type_default = {
 };
 
 // src/translator/visitors/import-declaration.ts
-var import_babel_utils48 = require("@marko/compiler/babel-utils");
+var import_babel_utils46 = 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_utils48.resolveTagImport)(importDecl, value);
+    const tagImport = (0, import_babel_utils46.resolveTagImport)(importDecl, value);
     if (tagImport) {
       node.extra ??= {};
       node.extra.tagImport = tagImport;
@@ -12218,26 +11330,8 @@ var import_declaration_default = {
 };
 
 // src/translator/visitors/placeholder.ts
-var import_compiler60 = require("@marko/compiler");
-
-// src/translator/util/is-non-html-text.ts
-var import_compiler59 = 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":
-      case "title":
-        return true;
-    }
-  }
-  return false;
-}
-
-// src/translator/visitors/placeholder.ts
-var kNodeBinding5 = Symbol("placeholder node binding");
+var import_compiler57 = require("@marko/compiler");
+var kNodeBinding2 = Symbol("placeholder node binding");
 var kSiblingText = Symbol("placeholder has sibling text");
 var kSharedText = Symbol(
   "placeholder will merge its visitor with a another node"
@@ -12255,7 +11349,7 @@ var placeholder_default = {
       }
     } else {
       const section = getOrCreateSection(placeholder);
-      const nodeBinding = (node.extra ??= {})[kNodeBinding5] = createBinding(
+      const nodeBinding = (node.extra ??= {})[kNodeBinding2] = createBinding(
         "#text",
         0 /* dom */,
         section
@@ -12278,7 +11372,7 @@ var placeholder_default = {
       const isHTML = isOutputHTML();
       const write = writeTo(placeholder);
       const extra = node.extra || {};
-      const nodeBinding = extra[kNodeBinding5];
+      const nodeBinding = extra[kNodeBinding2];
       const canWriteHTML = isHTML || confident && node.escape;
       const method = canWriteHTML ? node.escape ? "_escape" : "_unescaped" : node.escape ? "_text" : "_html";
       if (confident && canWriteHTML) {
@@ -12312,7 +11406,7 @@ var placeholder_default = {
             "render",
             getSection(placeholder),
             valueExtra.referencedBindings,
-            import_compiler60.types.expressionStatement(
+            import_compiler57.types.expressionStatement(
               method === "_text" ? callRuntime(
                 "_text",
                 createScopeReadExpression(nodeBinding),
@@ -12350,7 +11444,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!prev.node && import_compiler60.types.isProgram(placeholder.parentPath)) {
+  if (!prev.node && import_compiler57.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 1 /* Before */;
   }
   let next = placeholder.getNextSibling();
@@ -12367,7 +11461,7 @@ function analyzeSiblingText(placeholder) {
       break;
     }
   }
-  if (!next.node && import_compiler60.types.isProgram(placeholder.parentPath)) {
+  if (!next.node && import_compiler57.types.isProgram(placeholder.parentPath)) {
     return placeholderExtra[kSiblingText] = 2 /* After */;
   }
   return placeholderExtra[kSiblingText] = 0 /* None */;
@@ -12409,7 +11503,7 @@ function isEmptyPlaceholder(placeholder) {
 }
 
 // src/translator/visitors/referenced-identifier.ts
-var import_compiler61 = require("@marko/compiler");
+var import_compiler58 = require("@marko/compiler");
 var abortIdsByExpressionForSection = /* @__PURE__ */ new WeakMap();
 var referenced_identifier_default = {
   migrate(identifier) {
@@ -12417,8 +11511,8 @@ var referenced_identifier_default = {
     if (identifier.scope.hasBinding(name2)) return;
     switch (name2) {
       case "out":
-        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"));
+        if (import_compiler58.types.isMemberExpression(identifier.parent) && import_compiler58.types.isIdentifier(identifier.parent.property) && identifier.parent.property.name === "global") {
+          identifier.parentPath.replaceWith(import_compiler58.types.identifier("$global"));
         } else {
           throw identifier.buildCodeFrameError(
             "Only `out.global` is supported for compatibility."
@@ -12445,13 +11539,13 @@ var referenced_identifier_default = {
       case "$global":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler61.types.callExpression(importRuntime("$global"), [])
+            import_compiler58.types.callExpression(importRuntime("$global"), [])
           );
         } else {
           identifier.replaceWith(
-            import_compiler61.types.memberExpression(
+            import_compiler58.types.memberExpression(
               scopeIdentifier,
-              import_compiler61.types.identifier(getAccessorProp().Global)
+              import_compiler58.types.identifier(getAccessorProp().Global)
             )
           );
         }
@@ -12459,13 +11553,13 @@ var referenced_identifier_default = {
       case "$signal":
         if (isOutputHTML()) {
           identifier.replaceWith(
-            import_compiler61.types.callExpression(
-              import_compiler61.types.arrowFunctionExpression(
+            import_compiler58.types.callExpression(
+              import_compiler58.types.arrowFunctionExpression(
                 [],
-                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.")
+                import_compiler58.types.blockStatement([
+                  import_compiler58.types.throwStatement(
+                    import_compiler58.types.newExpression(import_compiler58.types.identifier("Error"), [
+                      import_compiler58.types.stringLiteral("Cannot use $signal in a server render.")
                     ])
                   )
                 ])
@@ -12491,19 +11585,19 @@ var referenced_identifier_default = {
               "render",
               section,
               exprRoot.node.extra?.referencedBindings,
-              import_compiler61.types.expressionStatement(
-                import_compiler61.types.callExpression(importRuntime("$signalReset"), [
+              import_compiler58.types.expressionStatement(
+                import_compiler58.types.callExpression(importRuntime("$signalReset"), [
                   scopeIdentifier,
-                  import_compiler61.types.numericLiteral(exprId)
+                  import_compiler58.types.numericLiteral(exprId)
                 ])
               ),
               false
             );
           }
           identifier.replaceWith(
-            import_compiler61.types.callExpression(importRuntime("$signal"), [
+            import_compiler58.types.callExpression(importRuntime("$signal"), [
               scopeIdentifier,
-              import_compiler61.types.numericLiteral(exprId)
+              import_compiler58.types.numericLiteral(exprId)
             ])
           );
         }
@@ -12512,7 +11606,7 @@ var referenced_identifier_default = {
 };
 
 // src/translator/visitors/scriptlet.ts
-var import_babel_utils49 = require("@marko/compiler/babel-utils");
+var import_babel_utils47 = require("@marko/compiler/babel-utils");
 var scriptlet_default = {
   analyze(scriptlet) {
     if (!scriptlet.node.static) {
@@ -12526,7 +11620,7 @@ var scriptlet_default = {
       scriptlet.node.body
     );
     if (scriptlet.node.target === "client") {
-      (0, import_babel_utils49.getProgram)().node.extra.isInteractive = true;
+      (0, import_babel_utils47.getProgram)().node.extra.isInteractive = true;
     }
   },
   translate: {
@@ -12547,21 +11641,21 @@ var scriptlet_default = {
 };
 
 // src/translator/visitors/tag/index.ts
-var import_compiler65 = require("@marko/compiler");
-var import_babel_utils53 = require("@marko/compiler/babel-utils");
+var import_compiler62 = require("@marko/compiler");
+var import_babel_utils51 = require("@marko/compiler/babel-utils");
 
 // src/translator/visitors/tag/attribute-tag.ts
-var import_compiler62 = require("@marko/compiler");
-var import_babel_utils50 = require("@marko/compiler/babel-utils");
+var import_compiler59 = require("@marko/compiler");
+var import_babel_utils48 = require("@marko/compiler/babel-utils");
 var attribute_tag_default = {
   analyze: {
     enter(tag) {
-      (0, import_babel_utils50.assertNoVar)(tag);
-      (0, import_babel_utils50.assertNoArgs)(tag);
+      (0, import_babel_utils48.assertNoVar)(tag);
+      (0, import_babel_utils48.assertNoArgs)(tag);
       const body = tag.get("body");
       startSection(body);
       trackParamsReferences(body, 3 /* param */);
-      if (!(0, import_babel_utils50.findParentTag)(tag)) {
+      if (!(0, import_babel_utils48.findParentTag)(tag)) {
         throw tag.get("name").buildCodeFrameError(
           "[Attribute tags](https://markojs.com/docs/reference/language#attribute-tags) must be nested within another tag."
         );
@@ -12584,13 +11678,13 @@ var attribute_tag_default = {
 };
 
 // src/translator/visitors/tag/custom-tag.ts
-var import_compiler63 = require("@marko/compiler");
-var import_babel_utils51 = require("@marko/compiler/babel-utils");
+var import_compiler60 = require("@marko/compiler");
+var import_babel_utils49 = require("@marko/compiler/babel-utils");
 var import_path4 = __toESM(require("path"));
 var custom_tag_default = {
   analyze: {
     enter(tag) {
-      const templateFile = (0, import_babel_utils51.getTagTemplate)(tag);
+      const templateFile = (0, import_babel_utils49.getTagTemplate)(tag);
       if (!templateFile) {
         const tagName = getTagName(tag);
         if (tagName && tag.scope.hasBinding(tagName)) {
@@ -12602,12 +11696,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_utils51.assertAttributesOrSingleArg)(tag);
-      const childFile = (0, import_babel_utils51.loadFileForTag)(tag);
+      (0, import_babel_utils49.assertAttributesOrSingleArg)(tag);
+      const childFile = (0, import_babel_utils49.loadFileForTag)(tag);
       if (!childFile) {
         throw tag.get("name").buildCodeFrameError("Unable to resolve file for tag.");
       }
-      const programSection = (0, import_babel_utils51.getProgram)().node.extra.section;
+      const programSection = (0, import_babel_utils49.getProgram)().node.extra.section;
       const childProgram = childFile.ast.program;
       const childExtra = childProgram.extra;
       const childSection = childExtra.section;
@@ -12635,12 +11729,12 @@ var custom_tag_default = {
 };
 function translateHTML(tag) {
   const { node } = tag;
-  const childProgram = (0, import_babel_utils51.loadFileForTag)(tag).ast.program;
+  const childProgram = (0, import_babel_utils49.loadFileForTag)(tag).ast.program;
   const childExtra = childProgram.extra;
   let tagIdentifier;
-  if (import_compiler63.types.isStringLiteral(node.name)) {
+  if (import_compiler60.types.isStringLiteral(node.name)) {
     const relativePath = getTagRelativePath(tag);
-    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler63.types.identifier(getTemplateContentName()) : (0, import_babel_utils51.importDefault)(tag.hub.file, relativePath, getTagName(tag));
+    tagIdentifier = isCircularRequest(tag.hub.file, relativePath) ? import_compiler60.types.identifier(getTemplateContentName()) : (0, import_babel_utils49.importDefault)(tag.hub.file, relativePath, getTagName(tag));
   } else {
     tagIdentifier = node.name;
   }
@@ -12656,12 +11750,12 @@ function translateDOM(tag) {
   const { file } = tag.hub;
   const write = writeTo(tag);
   const relativePath = getTagRelativePath(tag);
-  const programSection = (0, import_babel_utils51.getProgram)().node.extra.section;
-  const childFile = (0, import_babel_utils51.loadFileForTag)(tag);
+  const programSection = (0, import_babel_utils49.getProgram)().node.extra.section;
+  const childFile = (0, import_babel_utils49.loadFileForTag)(tag);
   const childExtra = childFile.ast.program.extra;
   const childExports = childExtra.domExports;
   const childSection = childExtra.section;
-  const tagName = import_compiler63.types.isIdentifier(node.name) ? node.name.name : import_compiler63.types.isStringLiteral(node.name) ? node.name.value : "tag";
+  const tagName = import_compiler60.types.isIdentifier(node.name) ? node.name.name : import_compiler60.types.isStringLiteral(node.name) ? node.name.value : "tag";
   if (programSection === childSection) {
     knownTagTranslateDOM(
       tag,
@@ -12672,16 +11766,16 @@ function translateDOM(tag) {
           "render",
           section,
           void 0,
-          import_compiler63.types.expressionStatement(
-            import_compiler63.types.callExpression(import_compiler63.types.identifier(childExports.setup), [
+          import_compiler60.types.expressionStatement(
+            import_compiler60.types.callExpression(import_compiler60.types.identifier(childExports.setup), [
               createScopeReadExpression(childBinding, section)
             ])
           )
         );
       }
     );
-    write`${import_compiler63.types.identifier(childExports.template)}`;
-    injectWalks(tag, tagName, import_compiler63.types.identifier(childExports.walks));
+    write`${import_compiler60.types.identifier(childExports.template)}`;
+    injectWalks(tag, tagName, import_compiler60.types.identifier(childExports.walks));
   } else {
     knownTagTranslateDOM(
       tag,
@@ -12697,8 +11791,8 @@ function translateDOM(tag) {
           "render",
           section,
           void 0,
-          import_compiler63.types.expressionStatement(
-            import_compiler63.types.callExpression(
+          import_compiler60.types.expressionStatement(
+            import_compiler60.types.callExpression(
               importOrSelfReferenceName(
                 file,
                 relativePath,
@@ -12711,11 +11805,11 @@ function translateDOM(tag) {
         );
       }
     );
-    write`${(0, import_babel_utils51.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
+    write`${(0, import_babel_utils49.importNamed)(file, relativePath, childExports.template, `${tagName}_template`)}`;
     injectWalks(
       tag,
       tagName,
-      (0, import_babel_utils51.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
+      (0, import_babel_utils49.importNamed)(file, relativePath, childExports.walks, `${tagName}_walks`)
     );
   }
   tag.remove();
@@ -12726,9 +11820,9 @@ function getTagRelativePath(tag) {
     hub: { file }
   } = tag;
   let relativePath;
-  if (import_compiler63.types.isStringLiteral(node.name)) {
-    const template = (0, import_babel_utils51.getTagTemplate)(tag);
-    relativePath = template && (0, import_babel_utils51.resolveRelativePath)(file, template);
+  if (import_compiler60.types.isStringLiteral(node.name)) {
+    const template = (0, import_babel_utils49.getTagTemplate)(tag);
+    relativePath = template && (0, import_babel_utils49.resolveRelativePath)(file, template);
   } else if (node.extra?.tagNameImported) {
     relativePath = node.extra.tagNameImported;
   }
@@ -12747,9 +11841,9 @@ function getTagRelativePath(tag) {
 }
 function importOrSelfReferenceName(file, request, name2, nameHint) {
   if (isCircularRequest(file, request)) {
-    return import_compiler63.types.identifier(name2);
+    return import_compiler60.types.identifier(name2);
   }
-  return (0, import_babel_utils51.importNamed)(file, request, name2, nameHint);
+  return (0, import_babel_utils49.importNamed)(file, request, name2, nameHint);
 }
 function isCircularRequest(file, request) {
   const { filename } = file.opts;
@@ -12757,15 +11851,15 @@ function isCircularRequest(file, request) {
 }
 
 // src/translator/visitors/tag/dynamic-tag.ts
-var import_compiler64 = require("@marko/compiler");
-var import_babel_utils52 = require("@marko/compiler/babel-utils");
+var import_compiler61 = require("@marko/compiler");
+var import_babel_utils50 = 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_utils52.assertAttributesOrArgs)(tag);
+      (0, import_babel_utils50.assertAttributesOrArgs)(tag);
       const { node } = tag;
       const definedBodySection = node.extra?.defineBodySection;
       if (definedBodySection) {
@@ -12790,9 +11884,9 @@ var dynamic_tag_default = {
         tagSection
       );
       if (hasVar || tag.node.attributes.some(
-        (attr) => import_compiler64.types.isMarkoSpreadAttribute(attr) || isEventOrChangeHandler(attr.name)
+        (attr) => import_compiler61.types.isMarkoSpreadAttribute(attr) || isEventOrChangeHandler(attr.name)
       )) {
-        (0, import_babel_utils52.getProgram)().node.extra.isInteractive = true;
+        (0, import_babel_utils50.getProgram)().node.extra.isInteractive = true;
       }
       if (hasVar) {
         trackVarReferences(tag, 5 /* derived */);
@@ -12830,7 +11924,7 @@ var dynamic_tag_default = {
         if (isOutputHTML()) {
           knownTagTranslateHTML(
             tag,
-            import_compiler64.types.memberExpression(tag.node.name, import_compiler64.types.identifier("content")),
+            import_compiler61.types.memberExpression(tag.node.name, import_compiler61.types.identifier("content")),
             definedBodySection,
             propTree
           );
@@ -12847,9 +11941,9 @@ var dynamic_tag_default = {
                   "render",
                   section,
                   void 0,
-                  import_compiler64.types.expressionStatement(
-                    import_compiler64.types.callExpression(
-                      import_compiler64.types.memberExpression(signal.identifier, import_compiler64.types.identifier("_")),
+                  import_compiler61.types.expressionStatement(
+                    import_compiler61.types.callExpression(
+                      import_compiler61.types.memberExpression(signal.identifier, import_compiler61.types.identifier("_")),
                       [
                         createScopeReadExpression(childBinding, section),
                         getScopeExpression(section, definedBodySection.parent)
@@ -12874,8 +11968,8 @@ var dynamic_tag_default = {
       const nodeBinding = tagExtra[kDOMBinding3];
       const isClassAPI = tagExtra.featureType === "class";
       let tagExpression = node.name;
-      if (import_compiler64.types.isStringLiteral(tagExpression)) {
-        tagExpression = (0, import_babel_utils52.importDefault)(
+      if (import_compiler61.types.isStringLiteral(tagExpression)) {
+        tagExpression = (0, import_babel_utils50.importDefault)(
           tag.hub.file,
           getTagRelativePath(tag),
           tagExpression.value
@@ -12883,15 +11977,15 @@ var dynamic_tag_default = {
       }
       if (isClassAPI) {
         if (isOutputHTML()) {
-          (0, import_babel_utils52.getProgram)().node.body.push(
-            import_compiler64.types.markoScriptlet(
+          (0, import_babel_utils50.getProgram)().node.body.push(
+            import_compiler61.types.markoScriptlet(
               [
-                import_compiler64.types.expressionStatement(
-                  import_compiler64.types.callExpression(
-                    (0, import_babel_utils52.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
+                import_compiler61.types.expressionStatement(
+                  import_compiler61.types.callExpression(
+                    (0, import_babel_utils50.importNamed)(tag.hub.file, getCompatRuntimeFile(), "s"),
                     [
-                      import_compiler64.types.identifier(tagExpression.name),
-                      import_compiler64.types.stringLiteral((0, import_babel_utils52.loadFileForTag)(tag).metadata.marko.id)
+                      import_compiler61.types.identifier(tagExpression.name),
+                      import_compiler61.types.stringLiteral((0, import_babel_utils50.loadFileForTag)(tag).metadata.marko.id)
                     ]
                   )
                 )
@@ -12900,12 +11994,12 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          (0, import_babel_utils52.getProgram)().node.body.push(
-            import_compiler64.types.expressionStatement(
+          (0, import_babel_utils50.getProgram)().node.body.push(
+            import_compiler61.types.expressionStatement(
               callRuntime(
                 "_resume",
-                import_compiler64.types.stringLiteral((0, import_babel_utils52.loadFileForTag)(tag).metadata.marko.id),
-                import_compiler64.types.identifier(tagExpression.name)
+                import_compiler61.types.stringLiteral((0, import_babel_utils50.loadFileForTag)(tag).metadata.marko.id),
+                import_compiler61.types.identifier(tagExpression.name)
               )
             )
           );
@@ -12948,9 +12042,9 @@ var dynamic_tag_default = {
           getScopeIdIdentifier(tagSection),
           getScopeAccessorLiteral(nodeBinding),
           tagExpression,
-          import_compiler64.types.arrayExpression(args),
-          import_compiler64.types.numericLiteral(0),
-          import_compiler64.types.numericLiteral(1),
+          import_compiler61.types.arrayExpression(args),
+          import_compiler61.types.numericLiteral(0),
+          import_compiler61.types.numericLiteral(1),
           serializeArg
         ) : callRuntime(
           "_dynamic_tag",
@@ -12958,8 +12052,8 @@ var dynamic_tag_default = {
           getScopeAccessorLiteral(nodeBinding),
           tagExpression,
           args[0],
-          args[1] || (serializeArg ? import_compiler64.types.numericLiteral(0) : void 0),
-          serializeArg ? import_compiler64.types.numericLiteral(0) : void 0,
+          args[1] || (serializeArg ? import_compiler61.types.numericLiteral(0) : void 0),
+          serializeArg ? import_compiler61.types.numericLiteral(0) : void 0,
           serializeArg
         );
         if (node.var) {
@@ -12967,18 +12061,18 @@ var dynamic_tag_default = {
             tag.get("name").toString() + "_scope"
           );
           statements.push(
-            import_compiler64.types.variableDeclaration("const", [
-              import_compiler64.types.variableDeclarator(
+            import_compiler61.types.variableDeclaration("const", [
+              import_compiler61.types.variableDeclarator(
                 dynamicScopeIdentifier,
                 callRuntime("_peek_scope_id")
               )
             ])
           );
           statements.push(
-            import_compiler64.types.variableDeclaration("let", [
-              import_compiler64.types.variableDeclarator(node.var, dynamicTagExpr)
+            import_compiler61.types.variableDeclaration("let", [
+              import_compiler61.types.variableDeclarator(node.var, dynamicTagExpr)
             ]),
-            import_compiler64.types.expressionStatement(
+            import_compiler61.types.expressionStatement(
               callRuntime(
                 "_var",
                 getScopeIdIdentifier(tagSection),
@@ -12986,7 +12080,7 @@ var dynamic_tag_default = {
                   tag.node.extra[kChildOffsetScopeBinding2]
                 ),
                 dynamicScopeIdentifier,
-                import_compiler64.types.stringLiteral(
+                import_compiler61.types.stringLiteral(
                   getResumeRegisterId(
                     tagSection,
                     node.var.extra?.binding,
@@ -12998,7 +12092,7 @@ var dynamic_tag_default = {
             )
           );
         } else {
-          statements.push(import_compiler64.types.expressionStatement(dynamicTagExpr));
+          statements.push(import_compiler61.types.expressionStatement(dynamicTagExpr));
         }
         for (const replacement of tag.replaceWithMultiple(statements)) {
           replacement.skip();
@@ -13017,9 +12111,9 @@ var dynamic_tag_default = {
           tagVarSignal.register = true;
           tagVarSignal.buildAssignment = (valueSection, value) => {
             const changeArgs = [
-              import_compiler64.types.memberExpression(
+              import_compiler61.types.memberExpression(
                 getScopeExpression(tagVarSignal.section, valueSection),
-                import_compiler64.types.stringLiteral(
+                import_compiler61.types.stringLiteral(
                   getAccessorPrefix().BranchScopes + getScopeAccessor(nodeBinding)
                 ),
                 true
@@ -13027,28 +12121,28 @@ var dynamic_tag_default = {
               value
             ];
             if (!isOptimize()) {
-              changeArgs.push(import_compiler64.types.stringLiteral(varBinding.name));
+              changeArgs.push(import_compiler61.types.stringLiteral(varBinding.name));
             }
-            return import_compiler64.types.callExpression(importRuntime("_var_change"), changeArgs);
+            return import_compiler61.types.callExpression(importRuntime("_var_change"), changeArgs);
           };
         }
         signal.build = () => {
           return callRuntime(
             "_dynamic_tag",
             getScopeAccessorLiteral(nodeBinding, true),
-            bodySection && import_compiler64.types.identifier(bodySection.name),
-            tagVarSignal ? import_compiler64.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
-            hasTagArgs && import_compiler64.types.numericLiteral(1)
+            bodySection && import_compiler61.types.identifier(bodySection.name),
+            tagVarSignal ? import_compiler61.types.arrowFunctionExpression([], tagVarSignal.identifier) : void 0,
+            hasTagArgs && import_compiler61.types.numericLiteral(1)
           );
         };
         if (args.length) {
-          const argsOrInput = hasTagArgs ? import_compiler64.types.arrayExpression(args) : args[0];
-          if (!import_compiler64.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
+          const argsOrInput = hasTagArgs ? import_compiler61.types.arrayExpression(args) : args[0];
+          if (!import_compiler61.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) {
             signal.extraArgs = [
-              import_compiler64.types.arrowFunctionExpression(
+              import_compiler61.types.arrowFunctionExpression(
                 [],
-                statements.length ? import_compiler64.types.blockStatement(
-                  statements.concat(import_compiler64.types.returnStatement(argsOrInput))
+                statements.length ? import_compiler61.types.blockStatement(
+                  statements.concat(import_compiler61.types.returnStatement(argsOrInput))
                 ) : argsOrInput
               )
             ];
@@ -13062,13 +12156,13 @@ var dynamic_tag_default = {
   }
 };
 function enableDynamicTagResume(tag) {
-  const program = (0, import_babel_utils52.getProgram)().node;
+  const program = (0, import_babel_utils50.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_compiler64.types.expressionStatement(callRuntime("_resume_dynamic_tag"))
+          import_compiler61.types.expressionStatement(callRuntime("_resume_dynamic_tag"))
         );
         return;
       }
@@ -13080,7 +12174,7 @@ function enableDynamicTagResume(tag) {
 var tag_default = {
   analyze: {
     enter(tag) {
-      const tagDef = (0, import_babel_utils53.getTagDef)(tag);
+      const tagDef = (0, import_babel_utils51.getTagDef)(tag);
       const type = analyzeTagNameType(tag);
       const hook = tagDef?.analyzer?.hook;
       if (hook) {
@@ -13104,7 +12198,7 @@ var tag_default = {
       }
     },
     exit(tag) {
-      const hook = (0, import_babel_utils53.getTagDef)(tag)?.analyzer?.hook;
+      const hook = (0, import_babel_utils51.getTagDef)(tag)?.analyzer?.hook;
       if (hook) {
         exit(hook, tag);
         return;
@@ -13113,8 +12207,7 @@ var tag_default = {
   },
   translate: {
     enter(tag) {
-      const tagDef = (0, import_babel_utils53.getTagDef)(tag);
-      const extra = tag.node.extra;
+      const tagDef = (0, import_babel_utils51.getTagDef)(tag);
       if (tagDef?.translator) {
         if (tagDef.translator.path) {
           tag.hub.file.metadata.marko.watchFiles.push(tagDef.translator.path);
@@ -13130,7 +12223,7 @@ var tag_default = {
             );
           }
           if (attr.node.modifier) {
-            if ((0, import_babel_utils53.isNativeTag)(attr.parentPath)) {
+            if ((0, import_babel_utils51.isNativeTag)(attr.parentPath)) {
               attr.node.name += `:${attr.node.modifier}`;
             } else {
               throw attr.buildCodeFrameError(
@@ -13140,18 +12233,7 @@ var tag_default = {
           }
         }
       }
-      const type = analyzeTagNameType(tag);
-      if (extra.tagNameDynamic && extra.tagNameNullable && type === 0 /* NativeTag */ && !tag.get("name").isIdentifier() && isOutputHTML()) {
-        const tagNameId = generateUidIdentifier("tagName");
-        const [tagNameVarPath] = tag.insertBefore(
-          import_compiler65.types.variableDeclaration("const", [
-            import_compiler65.types.variableDeclarator(tagNameId, tag.node.name)
-          ])
-        );
-        tagNameVarPath.skip();
-        tag.set("name", tagNameId);
-      }
-      switch (type) {
+      switch (analyzeTagNameType(tag)) {
         case 0 /* NativeTag */:
           native_tag_default.translate.enter(tag);
           break;
@@ -13167,7 +12249,7 @@ var tag_default = {
       }
     },
     exit(tag) {
-      const translator = (0, import_babel_utils53.getTagDef)(tag)?.translator;
+      const translator = (0, import_babel_utils51.getTagDef)(tag)?.translator;
       if (translator) {
         exit(translator.hook, tag);
         return;
@@ -13191,7 +12273,7 @@ var tag_default = {
 };
 
 // src/translator/visitors/text.ts
-var import_compiler66 = require("@marko/compiler");
+var import_compiler63 = require("@marko/compiler");
 var text_default = {
   translate: {
     exit(text) {
@@ -13223,7 +12305,7 @@ var preferAPI = "tags";
 var { transform, analyze, translate } = visitors;
 var taglibs = [
   [
-    __dirname,
+    core_default.taglibId,
     {
       ...core_default,
       migrate: visitors.migrate