@herb-tools/formatter 0.4.3 → 0.6.0

package/dist/index.esm.js

@@ -129,7 +129,7 @@ class Token {
 }
 
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-7/templates/javascript/packages/core/src/errors.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.0/templates/javascript/packages/core/src/errors.ts.erb
 class HerbError {
     type;
     message;
@@ -579,7 +579,7 @@ function convertToUTF8(string) {
 }
 
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-7/templates/javascript/packages/core/src/nodes.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.0/templates/javascript/packages/core/src/nodes.ts.erb
 class Node {
     type;
     location;
@@ -684,7 +684,6 @@ class DocumentNode extends Node {
         output += `@ DocumentNode ${this.location.treeInspectWithLabel()}\n`;
         output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
         output += `└── children: ${this.inspectArray(this.children, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -728,7 +727,6 @@ class LiteralNode extends Node {
         output += `@ LiteralNode ${this.location.treeInspectWithLabel()}\n`;
         output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
         output += `└── content: ${this.content ? JSON.stringify(this.content) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -795,13 +793,13 @@ class HTMLOpenTagNode extends Node {
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
         output += `└── is_void: ${typeof this.is_void === 'boolean' ? String(this.is_void) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
 class HTMLCloseTagNode extends Node {
     tag_opening;
     tag_name;
+    children;
     tag_closing;
     static from(data) {
         return new HTMLCloseTagNode({
@@ -810,6 +808,7 @@ class HTMLCloseTagNode extends Node {
             errors: (data.errors || []).map(error => HerbError.from(error)),
             tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
             tag_name: data.tag_name ? Token.from(data.tag_name) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
         });
     }
@@ -817,13 +816,16 @@ class HTMLCloseTagNode extends Node {
         super(props.type, props.location, props.errors);
         this.tag_opening = props.tag_opening;
         this.tag_name = props.tag_name;
+        this.children = props.children;
         this.tag_closing = props.tag_closing;
     }
     accept(visitor) {
         visitor.visitHTMLCloseTagNode(this);
     }
     childNodes() {
-        return [];
+        return [
+            ...this.children,
+        ];
     }
     compactChildNodes() {
         return this.childNodes().filter(node => node !== null && node !== undefined);
@@ -831,6 +833,7 @@ class HTMLCloseTagNode extends Node {
     recursiveErrors() {
         return [
             ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
         ].flat();
     }
     toJSON() {
@@ -839,6 +842,7 @@ class HTMLCloseTagNode extends Node {
             type: "AST_HTML_CLOSE_TAG_NODE",
             tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
             tag_name: this.tag_name ? this.tag_name.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
             tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
         };
     }
@@ -848,75 +852,8 @@ class HTMLCloseTagNode extends Node {
         output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
         output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
         output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
         output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
-        // output += "\n";
-        return output;
-    }
-}
-class HTMLSelfCloseTagNode extends Node {
-    tag_opening;
-    tag_name;
-    attributes;
-    tag_closing;
-    is_void;
-    static from(data) {
-        return new HTMLSelfCloseTagNode({
-            type: data.type,
-            location: Location.from(data.location),
-            errors: (data.errors || []).map(error => HerbError.from(error)),
-            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
-            tag_name: data.tag_name ? Token.from(data.tag_name) : null,
-            attributes: (data.attributes || []).map(node => fromSerializedNode(node)),
-            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
-            is_void: data.is_void,
-        });
-    }
-    constructor(props) {
-        super(props.type, props.location, props.errors);
-        this.tag_opening = props.tag_opening;
-        this.tag_name = props.tag_name;
-        this.attributes = props.attributes;
-        this.tag_closing = props.tag_closing;
-        this.is_void = props.is_void;
-    }
-    accept(visitor) {
-        visitor.visitHTMLSelfCloseTagNode(this);
-    }
-    childNodes() {
-        return [
-            ...this.attributes,
-        ];
-    }
-    compactChildNodes() {
-        return this.childNodes().filter(node => node !== null && node !== undefined);
-    }
-    recursiveErrors() {
-        return [
-            ...this.errors,
-            ...this.attributes.map(node => node.recursiveErrors()),
-        ].flat();
-    }
-    toJSON() {
-        return {
-            ...super.toJSON(),
-            type: "AST_HTML_SELF_CLOSE_TAG_NODE",
-            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
-            tag_name: this.tag_name ? this.tag_name.toJSON() : null,
-            attributes: this.attributes.map(node => node.toJSON()),
-            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
-            is_void: this.is_void,
-        };
-    }
-    treeInspect() {
-        let output = "";
-        output += `@ HTMLSelfCloseTagNode ${this.location.treeInspectWithLabel()}\n`;
-        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
-        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
-        output += `├── tag_name: ${this.tag_name ? this.tag_name.treeInspect() : "∅"}\n`;
-        output += `├── attributes: ${this.inspectArray(this.attributes, "│   ")}`;
-        output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
-        output += `└── is_void: ${typeof this.is_void === 'boolean' ? String(this.is_void) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -931,10 +868,10 @@ class HTMLElementNode extends Node {
             type: data.type,
             location: Location.from(data.location),
             errors: (data.errors || []).map(error => HerbError.from(error)),
-            open_tag: data.open_tag ? fromSerializedNode(data.open_tag) : null,
+            open_tag: data.open_tag ? fromSerializedNode((data.open_tag)) : null,
             tag_name: data.tag_name ? Token.from(data.tag_name) : null,
             body: (data.body || []).map(node => fromSerializedNode(node)),
-            close_tag: data.close_tag ? fromSerializedNode(data.close_tag) : null,
+            close_tag: data.close_tag ? fromSerializedNode((data.close_tag)) : null,
             is_void: data.is_void,
         });
     }
@@ -987,7 +924,6 @@ class HTMLElementNode extends Node {
         output += `├── body: ${this.inspectArray(this.body, "│   ")}`;
         output += `├── close_tag: ${this.inspectNode(this.close_tag, "│   ")}`;
         output += `└── is_void: ${typeof this.is_void === 'boolean' ? String(this.is_void) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -1049,29 +985,30 @@ class HTMLAttributeValueNode extends Node {
         output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
         output += `├── close_quote: ${this.close_quote ? this.close_quote.treeInspect() : "∅"}\n`;
         output += `└── quoted: ${typeof this.quoted === 'boolean' ? String(this.quoted) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
 class HTMLAttributeNameNode extends Node {
-    name;
+    children;
     static from(data) {
         return new HTMLAttributeNameNode({
             type: data.type,
             location: Location.from(data.location),
             errors: (data.errors || []).map(error => HerbError.from(error)),
-            name: data.name ? Token.from(data.name) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
         });
     }
     constructor(props) {
         super(props.type, props.location, props.errors);
-        this.name = props.name;
+        this.children = props.children;
     }
     accept(visitor) {
         visitor.visitHTMLAttributeNameNode(this);
     }
     childNodes() {
-        return [];
+        return [
+            ...this.children,
+        ];
     }
     compactChildNodes() {
         return this.childNodes().filter(node => node !== null && node !== undefined);
@@ -1079,21 +1016,21 @@ class HTMLAttributeNameNode extends Node {
     recursiveErrors() {
         return [
             ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
         ].flat();
     }
     toJSON() {
         return {
             ...super.toJSON(),
             type: "AST_HTML_ATTRIBUTE_NAME_NODE",
-            name: this.name ? this.name.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
         };
     }
     treeInspect() {
         let output = "";
         output += `@ HTMLAttributeNameNode ${this.location.treeInspectWithLabel()}\n`;
         output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
-        output += `└── name: ${this.name ? this.name.treeInspect() : "∅"}\n`;
-        // output += "\n";
+        output += `└── children: ${this.inspectArray(this.children, "    ")}`;
         return output;
     }
 }
@@ -1106,9 +1043,9 @@ class HTMLAttributeNode extends Node {
             type: data.type,
             location: Location.from(data.location),
             errors: (data.errors || []).map(error => HerbError.from(error)),
-            name: data.name ? fromSerializedNode(data.name) : null,
+            name: data.name ? fromSerializedNode((data.name)) : null,
             equals: data.equals ? Token.from(data.equals) : null,
-            value: data.value ? fromSerializedNode(data.value) : null,
+            value: data.value ? fromSerializedNode((data.value)) : null,
         });
     }
     constructor(props) {
@@ -1152,7 +1089,6 @@ class HTMLAttributeNode extends Node {
         output += `├── name: ${this.inspectNode(this.name, "│   ")}`;
         output += `├── equals: ${this.equals ? this.equals.treeInspect() : "∅"}\n`;
         output += `└── value: ${this.inspectNode(this.value, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1196,7 +1132,6 @@ class HTMLTextNode extends Node {
         output += `@ HTMLTextNode ${this.location.treeInspectWithLabel()}\n`;
         output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
         output += `└── content: ${this.content ? JSON.stringify(this.content) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -1253,7 +1188,6 @@ class HTMLCommentNode extends Node {
         output += `├── comment_start: ${this.comment_start ? this.comment_start.treeInspect() : "∅"}\n`;
         output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
         output += `└── comment_end: ${this.comment_end ? this.comment_end.treeInspect() : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -1310,7 +1244,118 @@ class HTMLDoctypeNode extends Node {
         output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
         output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
         output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
-        // output += "\n";
+        return output;
+    }
+}
+class XMLDeclarationNode extends Node {
+    tag_opening;
+    children;
+    tag_closing;
+    static from(data) {
+        return new XMLDeclarationNode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.children = props.children;
+        this.tag_closing = props.tag_closing;
+    }
+    accept(visitor) {
+        visitor.visitXMLDeclarationNode(this);
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ];
+    }
+    compactChildNodes() {
+        return this.childNodes().filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_XML_DECLARATION_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ XMLDeclarationNode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
+        return output;
+    }
+}
+class CDATANode extends Node {
+    tag_opening;
+    children;
+    tag_closing;
+    static from(data) {
+        return new CDATANode({
+            type: data.type,
+            location: Location.from(data.location),
+            errors: (data.errors || []).map(error => HerbError.from(error)),
+            tag_opening: data.tag_opening ? Token.from(data.tag_opening) : null,
+            children: (data.children || []).map(node => fromSerializedNode(node)),
+            tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.location, props.errors);
+        this.tag_opening = props.tag_opening;
+        this.children = props.children;
+        this.tag_closing = props.tag_closing;
+    }
+    accept(visitor) {
+        visitor.visitCDATANode(this);
+    }
+    childNodes() {
+        return [
+            ...this.children,
+        ];
+    }
+    compactChildNodes() {
+        return this.childNodes().filter(node => node !== null && node !== undefined);
+    }
+    recursiveErrors() {
+        return [
+            ...this.errors,
+            ...this.children.map(node => node.recursiveErrors()),
+        ].flat();
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "AST_CDATA_NODE",
+            tag_opening: this.tag_opening ? this.tag_opening.toJSON() : null,
+            children: this.children.map(node => node.toJSON()),
+            tag_closing: this.tag_closing ? this.tag_closing.toJSON() : null,
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ CDATANode ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
+        output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
+        output += `├── children: ${this.inspectArray(this.children, "│   ")}`;
+        output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         return output;
     }
 }
@@ -1354,7 +1399,6 @@ class WhitespaceNode extends Node {
         output += `@ WhitespaceNode ${this.location.treeInspectWithLabel()}\n`;
         output += `├── errors: ${this.inspectArray(this.errors, "│   ")}`;
         output += `└── value: ${this.value ? this.value.treeInspect() : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -1423,7 +1467,6 @@ class ERBContentNode extends Node {
         // no-op for analyzed_ruby
         output += `├── parsed: ${typeof this.parsed === 'boolean' ? String(this.parsed) : "∅"}\n`;
         output += `└── valid: ${typeof this.valid === 'boolean' ? String(this.valid) : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -1477,7 +1520,6 @@ class ERBEndNode extends Node {
         output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
         output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
         output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -1539,7 +1581,6 @@ class ERBElseNode extends Node {
         output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1559,8 +1600,8 @@ class ERBIfNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            subsequent: data.subsequent ? fromSerializedNode(data.subsequent) : null,
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            subsequent: data.subsequent ? fromSerializedNode((data.subsequent)) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -1615,7 +1656,6 @@ class ERBIfNode extends Node {
         output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
         output += `├── subsequent: ${this.inspectNode(this.subsequent, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1634,7 +1674,7 @@ class ERBBlockNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             body: (data.body || []).map(node => fromSerializedNode(node)),
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -1684,7 +1724,6 @@ class ERBBlockNode extends Node {
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `├── body: ${this.inspectArray(this.body, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1746,7 +1785,6 @@ class ERBWhenNode extends Node {
         output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1768,8 +1806,8 @@ class ERBCaseNode extends Node {
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             children: (data.children || []).map(node => fromSerializedNode(node)),
             conditions: (data.conditions || []).map(node => fromSerializedNode(node)),
-            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            else_clause: data.else_clause ? fromSerializedNode((data.else_clause)) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -1829,7 +1867,6 @@ class ERBCaseNode extends Node {
         output += `├── conditions: ${this.inspectArray(this.conditions, "│   ")}`;
         output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1851,8 +1888,8 @@ class ERBCaseMatchNode extends Node {
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             children: (data.children || []).map(node => fromSerializedNode(node)),
             conditions: (data.conditions || []).map(node => fromSerializedNode(node)),
-            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            else_clause: data.else_clause ? fromSerializedNode((data.else_clause)) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -1912,7 +1949,6 @@ class ERBCaseMatchNode extends Node {
         output += `├── conditions: ${this.inspectArray(this.conditions, "│   ")}`;
         output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -1931,7 +1967,7 @@ class ERBWhileNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -1981,7 +2017,6 @@ class ERBWhileNode extends Node {
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2000,7 +2035,7 @@ class ERBUntilNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -2050,7 +2085,6 @@ class ERBUntilNode extends Node {
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2069,7 +2103,7 @@ class ERBForNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -2119,7 +2153,6 @@ class ERBForNode extends Node {
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2138,7 +2171,7 @@ class ERBRescueNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            subsequent: data.subsequent ? fromSerializedNode(data.subsequent) : null,
+            subsequent: data.subsequent ? fromSerializedNode((data.subsequent)) : null,
         });
     }
     constructor(props) {
@@ -2188,7 +2221,6 @@ class ERBRescueNode extends Node {
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
         output += `└── subsequent: ${this.inspectNode(this.subsequent, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2250,7 +2282,6 @@ class ERBEnsureNode extends Node {
         output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2272,10 +2303,10 @@ class ERBBeginNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            rescue_clause: data.rescue_clause ? fromSerializedNode(data.rescue_clause) : null,
-            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
-            ensure_clause: data.ensure_clause ? fromSerializedNode(data.ensure_clause) : null,
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            rescue_clause: data.rescue_clause ? fromSerializedNode((data.rescue_clause)) : null,
+            else_clause: data.else_clause ? fromSerializedNode((data.else_clause)) : null,
+            ensure_clause: data.ensure_clause ? fromSerializedNode((data.ensure_clause)) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -2340,7 +2371,6 @@ class ERBBeginNode extends Node {
         output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
         output += `├── ensure_clause: ${this.inspectNode(this.ensure_clause, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2360,8 +2390,8 @@ class ERBUnlessNode extends Node {
             content: data.content ? Token.from(data.content) : null,
             tag_closing: data.tag_closing ? Token.from(data.tag_closing) : null,
             statements: (data.statements || []).map(node => fromSerializedNode(node)),
-            else_clause: data.else_clause ? fromSerializedNode(data.else_clause) : null,
-            end_node: data.end_node ? fromSerializedNode(data.end_node) : null,
+            else_clause: data.else_clause ? fromSerializedNode((data.else_clause)) : null,
+            end_node: data.end_node ? fromSerializedNode((data.end_node)) : null,
         });
     }
     constructor(props) {
@@ -2416,7 +2446,6 @@ class ERBUnlessNode extends Node {
         output += `├── statements: ${this.inspectArray(this.statements, "│   ")}`;
         output += `├── else_clause: ${this.inspectNode(this.else_clause, "│   ")}`;
         output += `└── end_node: ${this.inspectNode(this.end_node, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2470,7 +2499,6 @@ class ERBYieldNode extends Node {
         output += `├── tag_opening: ${this.tag_opening ? this.tag_opening.treeInspect() : "∅"}\n`;
         output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
         output += `└── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
-        // output += "\n";
         return output;
     }
 }
@@ -2532,7 +2560,6 @@ class ERBInNode extends Node {
         output += `├── content: ${this.content ? this.content.treeInspect() : "∅"}\n`;
         output += `├── tag_closing: ${this.tag_closing ? this.tag_closing.treeInspect() : "∅"}\n`;
         output += `└── statements: ${this.inspectArray(this.statements, "    ")}`;
-        // output += "\n";
         return output;
     }
 }
@@ -2542,7 +2569,6 @@ function fromSerializedNode(node) {
         case "AST_LITERAL_NODE": return LiteralNode.from(node);
         case "AST_HTML_OPEN_TAG_NODE": return HTMLOpenTagNode.from(node);
         case "AST_HTML_CLOSE_TAG_NODE": return HTMLCloseTagNode.from(node);
-        case "AST_HTML_SELF_CLOSE_TAG_NODE": return HTMLSelfCloseTagNode.from(node);
         case "AST_HTML_ELEMENT_NODE": return HTMLElementNode.from(node);
         case "AST_HTML_ATTRIBUTE_VALUE_NODE": return HTMLAttributeValueNode.from(node);
         case "AST_HTML_ATTRIBUTE_NAME_NODE": return HTMLAttributeNameNode.from(node);
@@ -2550,6 +2576,8 @@ function fromSerializedNode(node) {
         case "AST_HTML_TEXT_NODE": return HTMLTextNode.from(node);
         case "AST_HTML_COMMENT_NODE": return HTMLCommentNode.from(node);
         case "AST_HTML_DOCTYPE_NODE": return HTMLDoctypeNode.from(node);
+        case "AST_XML_DECLARATION_NODE": return XMLDeclarationNode.from(node);
+        case "AST_CDATA_NODE": return CDATANode.from(node);
         case "AST_WHITESPACE_NODE": return WhitespaceNode.from(node);
         case "AST_ERB_CONTENT_NODE": return ERBContentNode.from(node);
         case "AST_ERB_END_NODE": return ERBEndNode.from(node);
@@ -2573,63 +2601,613 @@ function fromSerializedNode(node) {
     }
 }
 
-// NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-7/templates/javascript/packages/core/src/visitor.ts.erb
-class Visitor {
-    visit(node) {
-        if (!node)
-            return;
-        node.accept(this);
-    }
-    visitAll(nodes) {
-        nodes.forEach(node => node?.accept(this));
-    }
-    visitChildNodes(node) {
-        node.compactChildNodes().forEach(node => node.accept(this));
-    }
-    visitDocumentNode(node) {
-        this.visitChildNodes(node);
-    }
-    visitLiteralNode(node) {
-        this.visitChildNodes(node);
+class Result {
+    source;
+    warnings;
+    errors;
+    constructor(source, warnings = [], errors = []) {
+        this.source = source;
+        this.warnings = warnings || [];
+        this.errors = errors || [];
     }
-    visitHTMLOpenTagNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Determines if the parsing was successful.
+     * @returns `true` if there are no errors, otherwise `false`.
+     */
+    get successful() {
+        return this.errors.length === 0;
     }
-    visitHTMLCloseTagNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Determines if the parsing failed.
+     * @returns `true` if there are errors, otherwise `false`.
+     */
+    get failed() {
+        return this.errors.length > 0;
     }
-    visitHTMLSelfCloseTagNode(node) {
-        this.visitChildNodes(node);
+}
+
+class HerbWarning {
+    message;
+    location;
+    static from(warning) {
+        return new HerbWarning(warning.message, Location.from(warning.location));
     }
-    visitHTMLElementNode(node) {
-        this.visitChildNodes(node);
+    constructor(message, location) {
+        this.message = message;
+        this.location = location;
     }
-    visitHTMLAttributeValueNode(node) {
-        this.visitChildNodes(node);
+}
+
+/**
+ * Represents the result of a parsing operation, extending the base `Result` class.
+ * It contains the parsed document node, source code, warnings, and errors.
+ */
+class ParseResult extends Result {
+    /** The document node generated from the source code. */
+    value;
+    /**
+     * Creates a `ParseResult` instance from a serialized result.
+     * @param result - The serialized parse result containing the value and source.
+     * @returns A new `ParseResult` instance.
+     */
+    static from(result) {
+        return new ParseResult(DocumentNode.from(result.value), result.source, result.warnings.map((warning) => HerbWarning.from(warning)), result.errors.map((error) => HerbError.from(error)));
     }
-    visitHTMLAttributeNameNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Constructs a new `ParseResult`.
+     * @param value - The document node.
+     * @param source - The source code that was parsed.
+     * @param warnings - An array of warnings encountered during parsing.
+     * @param errors - An array of errors encountered during parsing.
+     */
+    constructor(value, source, warnings = [], errors = []) {
+        super(source, warnings, errors);
+        this.value = value;
     }
-    visitHTMLAttributeNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Determines if the parsing failed.
+     * @returns `true` if there are errors, otherwise `false`.
+     */
+    get failed() {
+        // Consider errors on this result and recursively in the document tree
+        return this.recursiveErrors().length > 0;
     }
-    visitHTMLTextNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Determines if the parsing was successful.
+     * @returns `true` if there are no errors, otherwise `false`.
+     */
+    get successful() {
+        return !this.failed;
     }
-    visitHTMLCommentNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Returns a pretty-printed JSON string of the errors.
+     * @returns A string representation of the errors.
+     */
+    prettyErrors() {
+        return JSON.stringify([...this.errors, ...this.value.errors], null, 2);
     }
-    visitHTMLDoctypeNode(node) {
-        this.visitChildNodes(node);
+    recursiveErrors() {
+        return [...this.errors, ...this.value.recursiveErrors()];
     }
-    visitWhitespaceNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Returns a pretty-printed string of the parse result.
+     * @returns A string representation of the parse result.
+     */
+    inspect() {
+        return this.value.inspect();
     }
-    visitERBContentNode(node) {
-        this.visitChildNodes(node);
+    /**
+     * Accepts a visitor to traverse the document node.
+     * @param visitor - The visitor instance.
+     */
+    visit(visitor) {
+        visitor.visit(this.value);
     }
-    visitERBEndNode(node) {
+}
+
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.0/templates/javascript/packages/core/src/node-type-guards.ts.erb
+/**
+ * Type guard functions for AST nodes.
+ * These functions provide type checking by combining both instanceof
+ * checks and type string comparisons for maximum reliability across different
+ * runtime scenarios (e.g., serialized/deserialized nodes).
+ */
+/**
+ * Checks if a node is a DocumentNode
+ */
+function isDocumentNode(node) {
+    return node instanceof DocumentNode || node.type === "AST_DOCUMENT_NODE";
+}
+/**
+ * Checks if a node is a LiteralNode
+ */
+function isLiteralNode(node) {
+    return node instanceof LiteralNode || node.type === "AST_LITERAL_NODE";
+}
+/**
+ * Checks if a node is a HTMLOpenTagNode
+ */
+function isHTMLOpenTagNode(node) {
+    return node instanceof HTMLOpenTagNode || node.type === "AST_HTML_OPEN_TAG_NODE";
+}
+/**
+ * Checks if a node is a HTMLCloseTagNode
+ */
+function isHTMLCloseTagNode(node) {
+    return node instanceof HTMLCloseTagNode || node.type === "AST_HTML_CLOSE_TAG_NODE";
+}
+/**
+ * Checks if a node is a HTMLElementNode
+ */
+function isHTMLElementNode(node) {
+    return node instanceof HTMLElementNode || node.type === "AST_HTML_ELEMENT_NODE";
+}
+/**
+ * Checks if a node is a HTMLAttributeValueNode
+ */
+function isHTMLAttributeValueNode(node) {
+    return node instanceof HTMLAttributeValueNode || node.type === "AST_HTML_ATTRIBUTE_VALUE_NODE";
+}
+/**
+ * Checks if a node is a HTMLAttributeNameNode
+ */
+function isHTMLAttributeNameNode(node) {
+    return node instanceof HTMLAttributeNameNode || node.type === "AST_HTML_ATTRIBUTE_NAME_NODE";
+}
+/**
+ * Checks if a node is a HTMLAttributeNode
+ */
+function isHTMLAttributeNode(node) {
+    return node instanceof HTMLAttributeNode || node.type === "AST_HTML_ATTRIBUTE_NODE";
+}
+/**
+ * Checks if a node is a HTMLTextNode
+ */
+function isHTMLTextNode(node) {
+    return node instanceof HTMLTextNode || node.type === "AST_HTML_TEXT_NODE";
+}
+/**
+ * Checks if a node is a HTMLCommentNode
+ */
+function isHTMLCommentNode(node) {
+    return node instanceof HTMLCommentNode || node.type === "AST_HTML_COMMENT_NODE";
+}
+/**
+ * Checks if a node is a HTMLDoctypeNode
+ */
+function isHTMLDoctypeNode(node) {
+    return node instanceof HTMLDoctypeNode || node.type === "AST_HTML_DOCTYPE_NODE";
+}
+/**
+ * Checks if a node is a XMLDeclarationNode
+ */
+function isXMLDeclarationNode(node) {
+    return node instanceof XMLDeclarationNode || node.type === "AST_XML_DECLARATION_NODE";
+}
+/**
+ * Checks if a node is a CDATANode
+ */
+function isCDATANode(node) {
+    return node instanceof CDATANode || node.type === "AST_CDATA_NODE";
+}
+/**
+ * Checks if a node is a WhitespaceNode
+ */
+function isWhitespaceNode(node) {
+    return node instanceof WhitespaceNode || node.type === "AST_WHITESPACE_NODE";
+}
+/**
+ * Checks if a node is a ERBContentNode
+ */
+function isERBContentNode(node) {
+    return node instanceof ERBContentNode || node.type === "AST_ERB_CONTENT_NODE";
+}
+/**
+ * Checks if a node is a ERBEndNode
+ */
+function isERBEndNode(node) {
+    return node instanceof ERBEndNode || node.type === "AST_ERB_END_NODE";
+}
+/**
+ * Checks if a node is a ERBElseNode
+ */
+function isERBElseNode(node) {
+    return node instanceof ERBElseNode || node.type === "AST_ERB_ELSE_NODE";
+}
+/**
+ * Checks if a node is a ERBIfNode
+ */
+function isERBIfNode(node) {
+    return node instanceof ERBIfNode || node.type === "AST_ERB_IF_NODE";
+}
+/**
+ * Checks if a node is a ERBBlockNode
+ */
+function isERBBlockNode(node) {
+    return node instanceof ERBBlockNode || node.type === "AST_ERB_BLOCK_NODE";
+}
+/**
+ * Checks if a node is a ERBWhenNode
+ */
+function isERBWhenNode(node) {
+    return node instanceof ERBWhenNode || node.type === "AST_ERB_WHEN_NODE";
+}
+/**
+ * Checks if a node is a ERBCaseNode
+ */
+function isERBCaseNode(node) {
+    return node instanceof ERBCaseNode || node.type === "AST_ERB_CASE_NODE";
+}
+/**
+ * Checks if a node is a ERBCaseMatchNode
+ */
+function isERBCaseMatchNode(node) {
+    return node instanceof ERBCaseMatchNode || node.type === "AST_ERB_CASE_MATCH_NODE";
+}
+/**
+ * Checks if a node is a ERBWhileNode
+ */
+function isERBWhileNode(node) {
+    return node instanceof ERBWhileNode || node.type === "AST_ERB_WHILE_NODE";
+}
+/**
+ * Checks if a node is a ERBUntilNode
+ */
+function isERBUntilNode(node) {
+    return node instanceof ERBUntilNode || node.type === "AST_ERB_UNTIL_NODE";
+}
+/**
+ * Checks if a node is a ERBForNode
+ */
+function isERBForNode(node) {
+    return node instanceof ERBForNode || node.type === "AST_ERB_FOR_NODE";
+}
+/**
+ * Checks if a node is a ERBRescueNode
+ */
+function isERBRescueNode(node) {
+    return node instanceof ERBRescueNode || node.type === "AST_ERB_RESCUE_NODE";
+}
+/**
+ * Checks if a node is a ERBEnsureNode
+ */
+function isERBEnsureNode(node) {
+    return node instanceof ERBEnsureNode || node.type === "AST_ERB_ENSURE_NODE";
+}
+/**
+ * Checks if a node is a ERBBeginNode
+ */
+function isERBBeginNode(node) {
+    return node instanceof ERBBeginNode || node.type === "AST_ERB_BEGIN_NODE";
+}
+/**
+ * Checks if a node is a ERBUnlessNode
+ */
+function isERBUnlessNode(node) {
+    return node instanceof ERBUnlessNode || node.type === "AST_ERB_UNLESS_NODE";
+}
+/**
+ * Checks if a node is a ERBYieldNode
+ */
+function isERBYieldNode(node) {
+    return node instanceof ERBYieldNode || node.type === "AST_ERB_YIELD_NODE";
+}
+/**
+ * Checks if a node is a ERBInNode
+ */
+function isERBInNode(node) {
+    return node instanceof ERBInNode || node.type === "AST_ERB_IN_NODE";
+}
+/**
+ * Checks if a node is any ERB node type
+ */
+function isERBNode(node) {
+    return isERBContentNode(node) ||
+        isERBEndNode(node) ||
+        isERBElseNode(node) ||
+        isERBIfNode(node) ||
+        isERBBlockNode(node) ||
+        isERBWhenNode(node) ||
+        isERBCaseNode(node) ||
+        isERBCaseMatchNode(node) ||
+        isERBWhileNode(node) ||
+        isERBUntilNode(node) ||
+        isERBForNode(node) ||
+        isERBRescueNode(node) ||
+        isERBEnsureNode(node) ||
+        isERBBeginNode(node) ||
+        isERBUnlessNode(node) ||
+        isERBYieldNode(node) ||
+        isERBInNode(node);
+}
+/**
+ * Map of node classes to their corresponding type guard functions
+ *
+ * @example
+ * const guard = NODE_TYPE_GUARDS[HTMLTextNode]
+ *
+ * if (guard(node)) {
+ *   // node is HTMLTextNode
+ * }
+ */
+const NODE_TYPE_GUARDS = new Map([
+    [DocumentNode, isDocumentNode],
+    [LiteralNode, isLiteralNode],
+    [HTMLOpenTagNode, isHTMLOpenTagNode],
+    [HTMLCloseTagNode, isHTMLCloseTagNode],
+    [HTMLElementNode, isHTMLElementNode],
+    [HTMLAttributeValueNode, isHTMLAttributeValueNode],
+    [HTMLAttributeNameNode, isHTMLAttributeNameNode],
+    [HTMLAttributeNode, isHTMLAttributeNode],
+    [HTMLTextNode, isHTMLTextNode],
+    [HTMLCommentNode, isHTMLCommentNode],
+    [HTMLDoctypeNode, isHTMLDoctypeNode],
+    [XMLDeclarationNode, isXMLDeclarationNode],
+    [CDATANode, isCDATANode],
+    [WhitespaceNode, isWhitespaceNode],
+    [ERBContentNode, isERBContentNode],
+    [ERBEndNode, isERBEndNode],
+    [ERBElseNode, isERBElseNode],
+    [ERBIfNode, isERBIfNode],
+    [ERBBlockNode, isERBBlockNode],
+    [ERBWhenNode, isERBWhenNode],
+    [ERBCaseNode, isERBCaseNode],
+    [ERBCaseMatchNode, isERBCaseMatchNode],
+    [ERBWhileNode, isERBWhileNode],
+    [ERBUntilNode, isERBUntilNode],
+    [ERBForNode, isERBForNode],
+    [ERBRescueNode, isERBRescueNode],
+    [ERBEnsureNode, isERBEnsureNode],
+    [ERBBeginNode, isERBBeginNode],
+    [ERBUnlessNode, isERBUnlessNode],
+    [ERBYieldNode, isERBYieldNode],
+    [ERBInNode, isERBInNode],
+]);
+/**
+ * Map of AST node type strings to their corresponding type guard functions
+ *
+ * @example
+ * const guard = AST_TYPE_GUARDS["AST_HTML_TEXT_NODE"]
+ *
+ * if (guard(node)) {
+ *   // node is HTMLTextNode
+ * }
+ */
+const AST_TYPE_GUARDS = new Map([
+    ["AST_DOCUMENT_NODE", isDocumentNode],
+    ["AST_LITERAL_NODE", isLiteralNode],
+    ["AST_HTML_OPEN_TAG_NODE", isHTMLOpenTagNode],
+    ["AST_HTML_CLOSE_TAG_NODE", isHTMLCloseTagNode],
+    ["AST_HTML_ELEMENT_NODE", isHTMLElementNode],
+    ["AST_HTML_ATTRIBUTE_VALUE_NODE", isHTMLAttributeValueNode],
+    ["AST_HTML_ATTRIBUTE_NAME_NODE", isHTMLAttributeNameNode],
+    ["AST_HTML_ATTRIBUTE_NODE", isHTMLAttributeNode],
+    ["AST_HTML_TEXT_NODE", isHTMLTextNode],
+    ["AST_HTML_COMMENT_NODE", isHTMLCommentNode],
+    ["AST_HTML_DOCTYPE_NODE", isHTMLDoctypeNode],
+    ["AST_XML_DECLARATION_NODE", isXMLDeclarationNode],
+    ["AST_CDATA_NODE", isCDATANode],
+    ["AST_WHITESPACE_NODE", isWhitespaceNode],
+    ["AST_ERB_CONTENT_NODE", isERBContentNode],
+    ["AST_ERB_END_NODE", isERBEndNode],
+    ["AST_ERB_ELSE_NODE", isERBElseNode],
+    ["AST_ERB_IF_NODE", isERBIfNode],
+    ["AST_ERB_BLOCK_NODE", isERBBlockNode],
+    ["AST_ERB_WHEN_NODE", isERBWhenNode],
+    ["AST_ERB_CASE_NODE", isERBCaseNode],
+    ["AST_ERB_CASE_MATCH_NODE", isERBCaseMatchNode],
+    ["AST_ERB_WHILE_NODE", isERBWhileNode],
+    ["AST_ERB_UNTIL_NODE", isERBUntilNode],
+    ["AST_ERB_FOR_NODE", isERBForNode],
+    ["AST_ERB_RESCUE_NODE", isERBRescueNode],
+    ["AST_ERB_ENSURE_NODE", isERBEnsureNode],
+    ["AST_ERB_BEGIN_NODE", isERBBeginNode],
+    ["AST_ERB_UNLESS_NODE", isERBUnlessNode],
+    ["AST_ERB_YIELD_NODE", isERBYieldNode],
+    ["AST_ERB_IN_NODE", isERBInNode],
+]);
+/**
+ * Checks if a node matches any of the provided type identifiers with proper type narrowing
+ * Supports AST type strings, node classes, or type guard functions
+ *
+ * @example
+ * if (isAnyOf(node, "AST_HTML_TEXT_NODE", "AST_LITERAL_NODE")) {
+ *   // node is narrowed to HTMLTextNode | LiteralNode
+ * }
+ *
+ * @example
+ * if (isAnyOf(node, HTMLTextNode, LiteralNode)) {
+ *   // node is narrowed to HTMLTextNode | LiteralNode
+ * }
+ */
+function isAnyOf(node, ...types) {
+    return types.some(type => {
+        if (typeof type === 'string') {
+            return isNode(node, type);
+        }
+        else if (typeof type === 'function' && type.prototype && type.prototype.constructor === type && NODE_TYPE_GUARDS.has(type)) {
+            return isNode(node, type);
+        }
+        else if (typeof type === 'function') {
+            return type(node);
+        }
+        else {
+            return false;
+        }
+    });
+}
+/**
+ * Checks if a node does NOT match any of the provided type identifiers
+ * Supports AST type strings, node classes, or type guard functions
+ * This is the logical inverse of isAnyOf
+ *
+ * @example
+ * if (isNoneOf(node, "AST_HTML_TEXT_NODE", "AST_LITERAL_NODE")) {
+ *   // node is neither HTMLTextNode nor LiteralNode
+ * }
+ *
+ * @example
+ * if (isNoneOf(node, HTMLTextNode, LiteralNode)) {
+ *   // node is neither HTMLTextNode nor LiteralNode
+ * }
+ *
+ * @example
+ * if (isNoneOf(node, isHTMLTextNode, isLiteralNode)) {
+ *   // node is neither HTMLTextNode nor LiteralNode
+ * }
+ */
+function isNoneOf(node, ...types) {
+    return !isAnyOf(node, ...types);
+}
+function filterNodes(nodes, ...types) {
+    if (!nodes)
+        return [];
+    return nodes.filter(node => isAnyOf(node, ...types));
+}
+function isNode(node, type) {
+    if (typeof type === 'string') {
+        const guard = AST_TYPE_GUARDS.get(type);
+        return guard ? guard(node) : false;
+    }
+    else if (typeof type === 'function') {
+        const guard = NODE_TYPE_GUARDS.get(type);
+        return guard ? guard(node) : false;
+    }
+    else {
+        return false;
+    }
+}
+function isToken(object) {
+    return (object instanceof Token) || (object?.constructor?.name === "Token" && "value" in object) || object.type?.startsWith('TOKEN_');
+}
+function isParseResult(object) {
+    return (object instanceof ParseResult) || (object?.constructor?.name === "ParseResult" && "value" in object);
+}
+
+/**
+ * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
+ */
+function isERBOutputNode(node) {
+    return isNode(node, ERBContentNode) && ["<%=", "<%=="].includes(node.tag_opening?.value);
+}
+/**
+ * Checks if a node is a non-output ERB node (control flow: <% %>)
+ */
+function isERBControlFlowNode(node) {
+    return isAnyOf(node, ERBIfNode, ERBUnlessNode, ERBBlockNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBForNode, ERBBeginNode);
+}
+/**
+ * Checks if an array of nodes contains any ERB output nodes (dynamic content)
+ */
+function hasERBOutput(nodes) {
+    return nodes.some(isERBOutputNode);
+}
+/**
+ * Extracts a combined string from nodes, including ERB content
+ * For ERB nodes, includes the full tag syntax (e.g., "<%= foo %>")
+ * This is useful for debugging or displaying the full attribute name
+ */
+function getCombinedStringFromNodes(nodes) {
+    return nodes.map(node => {
+        if (isLiteralNode(node)) {
+            return node.content;
+        }
+        else if (isERBContentNode(node)) {
+            const opening = node.tag_opening?.value || "";
+            const content = node.content?.value || "";
+            const closing = node.tag_closing?.value || "";
+            return `${opening}${content}${closing}`;
+        }
+        else {
+            // For other node types, return a placeholder or empty string
+            return `[${node.type}]`;
+        }
+    }).join("");
+}
+/**
+ * Gets the combined string representation of an HTML attribute name node
+ * This includes both static and dynamic content, useful for debugging
+ */
+function getCombinedAttributeName(attributeNameNode) {
+    if (!attributeNameNode.children) {
+        return "";
+    }
+    return getCombinedStringFromNodes(attributeNameNode.children);
+}
+/**
+ * Gets the tag name of an HTML element node
+ */
+function getTagName(node) {
+    return node.tag_name?.value ?? "";
+}
+/**
+ * Check if a node is a comment (HTML comment or ERB comment)
+ */
+function isCommentNode(node) {
+    return isNode(node, HTMLCommentNode) || (isERBNode(node) && !isERBControlFlowNode(node));
+}
+
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.6.0/templates/javascript/packages/core/src/visitor.ts.erb
+class Visitor {
+    visit(node) {
+        if (!node)
+            return;
+        node.accept(this);
+    }
+    visitAll(nodes) {
+        nodes.forEach(node => node?.accept(this));
+    }
+    visitChildNodes(node) {
+        node.compactChildNodes().forEach(node => node.accept(this));
+    }
+    visitDocumentNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitLiteralNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLOpenTagNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLCloseTagNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLElementNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLAttributeValueNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLAttributeNameNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLAttributeNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLTextNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLCommentNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLDoctypeNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitXMLDeclarationNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitCDATANode(node) {
+        this.visitChildNodes(node);
+    }
+    visitWhitespaceNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitERBContentNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitERBEndNode(node) {
         this.visitChildNodes(node);
     }
     visitERBElseNode(node) {
@@ -2674,51 +3252,573 @@ class Visitor {
     visitERBYieldNode(node) {
         this.visitChildNodes(node);
     }
-    visitERBInNode(node) {
-        this.visitChildNodes(node);
+    visitERBInNode(node) {
+        this.visitChildNodes(node);
+    }
+}
+
+class PrintContext {
+    output = "";
+    indentLevel = 0;
+    currentColumn = 0;
+    preserveStack = [];
+    /**
+     * Write text to the output
+     */
+    write(text) {
+        this.output += text;
+        this.currentColumn += text.length;
+    }
+    /**
+     * Write text and update column tracking for newlines
+     */
+    writeWithColumnTracking(text) {
+        this.output += text;
+        const lines = text.split('\n');
+        if (lines.length > 1) {
+            this.currentColumn = lines[lines.length - 1].length;
+        }
+        else {
+            this.currentColumn += text.length;
+        }
+    }
+    /**
+     * Increase indentation level
+     */
+    indent() {
+        this.indentLevel++;
+    }
+    /**
+     * Decrease indentation level
+     */
+    dedent() {
+        if (this.indentLevel > 0) {
+            this.indentLevel--;
+        }
+    }
+    /**
+     * Enter a tag that may preserve whitespace
+     */
+    enterTag(tagName) {
+        this.preserveStack.push(tagName.toLowerCase());
+    }
+    /**
+     * Exit the current tag
+     */
+    exitTag() {
+        this.preserveStack.pop();
+    }
+    /**
+     * Check if we're at the start of a line
+     */
+    isAtStartOfLine() {
+        return this.currentColumn === 0;
+    }
+    /**
+     * Get current indentation level
+     */
+    getCurrentIndentLevel() {
+        return this.indentLevel;
+    }
+    /**
+     * Get current column position
+     */
+    getCurrentColumn() {
+        return this.currentColumn;
+    }
+    /**
+     * Get the current tag stack (for debugging)
+     */
+    getTagStack() {
+        return [...this.preserveStack];
+    }
+    /**
+     * Get the complete output string
+     */
+    getOutput() {
+        return this.output;
+    }
+    /**
+     * Reset the context for reuse
+     */
+    reset() {
+        this.output = "";
+        this.indentLevel = 0;
+        this.currentColumn = 0;
+        this.preserveStack = [];
+    }
+}
+
+/**
+ * Default print options used when none are provided
+ */
+const DEFAULT_PRINT_OPTIONS = {
+    ignoreErrors: false
+};
+class Printer extends Visitor {
+    context = new PrintContext();
+    /**
+     * Static method to print a node without creating an instance
+     *
+     * @param input - The AST Node, Token, or ParseResult to print
+     * @param options - Print options to control behavior
+     * @returns The printed string representation of the input
+     * @throws {Error} When node has parse errors and ignoreErrors is false
+     */
+    static print(input, options = DEFAULT_PRINT_OPTIONS) {
+        const printer = new this();
+        return printer.print(input, options);
+    }
+    /**
+     * Print a node, token, or parse result to a string
+     *
+     * @param input - The AST Node, Token, or ParseResult to print
+     * @param options - Print options to control behavior
+     * @returns The printed string representation of the input
+     * @throws {Error} When node has parse errors and ignoreErrors is false
+     */
+    print(input, options = DEFAULT_PRINT_OPTIONS) {
+        if (isToken(input)) {
+            return input.value;
+        }
+        const node = isParseResult(input) ? input.value : input;
+        if (options.ignoreErrors === false && node.recursiveErrors().length > 0) {
+            throw new Error(`Cannot print the node (${node.type}) since it or any of its children has parse errors. Either pass in a valid Node or call \`print()\` using \`print(node, { ignoreErrors: true })\``);
+        }
+        this.context.reset();
+        this.visit(node);
+        return this.context.getOutput();
+    }
+    visitDocumentNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitLiteralNode(node) {
+        this.context.write(node.content);
+    }
+    visitHTMLTextNode(node) {
+        this.write(node.content);
+    }
+    visitWhitespaceNode(node) {
+        if (node.value) {
+            this.write(node.value.value);
+        }
+    }
+    visitHTMLOpenTagNode(node) {
+        if (node.tag_opening) {
+            this.context.write(node.tag_opening.value);
+        }
+        if (node.tag_name) {
+            this.context.write(node.tag_name.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.context.write(node.tag_closing.value);
+        }
+    }
+    visitHTMLCloseTagNode(node) {
+        if (node.tag_opening) {
+            this.context.write(node.tag_opening.value);
+        }
+        if (node.tag_name) {
+            this.context.write(node.tag_name.value);
+        }
+        if (node.tag_closing) {
+            this.context.write(node.tag_closing.value);
+        }
+    }
+    visitHTMLElementNode(node) {
+        const tagName = node.tag_name?.value;
+        if (tagName) {
+            this.context.enterTag(tagName);
+        }
+        if (node.open_tag) {
+            this.visit(node.open_tag);
+        }
+        if (node.body) {
+            node.body.forEach(child => this.visit(child));
+        }
+        if (node.close_tag) {
+            this.visit(node.close_tag);
+        }
+        if (tagName) {
+            this.context.exitTag();
+        }
+    }
+    visitHTMLAttributeNode(node) {
+        if (node.name) {
+            this.visit(node.name);
+        }
+        if (node.equals) {
+            this.context.write(node.equals.value);
+        }
+        if (node.equals && node.value) {
+            this.visit(node.value);
+        }
+    }
+    visitHTMLAttributeNameNode(node) {
+        this.visitChildNodes(node);
+    }
+    visitHTMLAttributeValueNode(node) {
+        if (node.quoted && node.open_quote) {
+            this.context.write(node.open_quote.value);
+        }
+        this.visitChildNodes(node);
+        if (node.quoted && node.close_quote) {
+            this.context.write(node.close_quote.value);
+        }
+    }
+    visitHTMLCommentNode(node) {
+        if (node.comment_start) {
+            this.context.write(node.comment_start.value);
+        }
+        this.visitChildNodes(node);
+        if (node.comment_end) {
+            this.context.write(node.comment_end.value);
+        }
+    }
+    visitHTMLDoctypeNode(node) {
+        if (node.tag_opening) {
+            this.context.write(node.tag_opening.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.context.write(node.tag_closing.value);
+        }
+    }
+    visitXMLDeclarationNode(node) {
+        if (node.tag_opening) {
+            this.context.write(node.tag_opening.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.context.write(node.tag_closing.value);
+        }
+    }
+    visitCDATANode(node) {
+        if (node.tag_opening) {
+            this.context.write(node.tag_opening.value);
+        }
+        this.visitChildNodes(node);
+        if (node.tag_closing) {
+            this.context.write(node.tag_closing.value);
+        }
+    }
+    visitERBContentNode(node) {
+        this.printERBNode(node);
+    }
+    visitERBIfNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.subsequent) {
+            this.visit(node.subsequent);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBElseNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBEndNode(node) {
+        this.printERBNode(node);
+    }
+    visitERBBlockNode(node) {
+        this.printERBNode(node);
+        if (node.body) {
+            node.body.forEach(child => this.visit(child));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBCaseNode(node) {
+        this.printERBNode(node);
+        if (node.children) {
+            node.children.forEach(child => this.visit(child));
+        }
+        if (node.conditions) {
+            node.conditions.forEach(condition => this.visit(condition));
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBWhenNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBWhileNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBUntilNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBForNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBBeginNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.rescue_clause) {
+            this.visit(node.rescue_clause);
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.ensure_clause) {
+            this.visit(node.ensure_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBRescueNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.subsequent) {
+            this.visit(node.subsequent);
+        }
+    }
+    visitERBEnsureNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBUnlessNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    visitERBYieldNode(node) {
+        this.printERBNode(node);
+    }
+    visitERBInNode(node) {
+        this.printERBNode(node);
+        if (node.statements) {
+            node.statements.forEach(statement => this.visit(statement));
+        }
+    }
+    visitERBCaseMatchNode(node) {
+        this.printERBNode(node);
+        if (node.children) {
+            node.children.forEach(child => this.visit(child));
+        }
+        if (node.conditions) {
+            node.conditions.forEach(condition => this.visit(condition));
+        }
+        if (node.else_clause) {
+            this.visit(node.else_clause);
+        }
+        if (node.end_node) {
+            this.visit(node.end_node);
+        }
+    }
+    /**
+     * Print ERB node tags and content
+     */
+    printERBNode(node) {
+        if (node.tag_opening) {
+            this.context.write(node.tag_opening.value);
+        }
+        if (node.content) {
+            this.context.write(node.content.value);
+        }
+        if (node.tag_closing) {
+            this.context.write(node.tag_closing.value);
+        }
     }
+    write(content) {
+        this.context.write(content);
+    }
+}
+
+/**
+ * IdentityPrinter - Provides lossless reconstruction of the original source
+ *
+ * This printer aims to reconstruct the original input as faithfully as possible,
+ * preserving all whitespace, formatting, and structure. It's useful for:
+ * - Testing parser accuracy (input should equal output)
+ * - Baseline printing before applying transformations
+ * - Verifying AST round-trip fidelity
+ */
+class IdentityPrinter extends Printer {
 }
 
+// TODO: we can probably expand this list with more tags/attributes
+const FORMATTABLE_ATTRIBUTES = {
+    '*': ['class'],
+    'img': ['srcset', 'sizes']
+};
 /**
  * Printer traverses the Herb AST using the Visitor pattern
  * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
  */
-class Printer extends Visitor {
+class FormatPrinter extends Printer {
+    /**
+     * @deprecated integrate indentWidth into this.options and update FormatOptions to extend from @herb-tools/printer options
+     */
     indentWidth;
+    /**
+     * @deprecated integrate maxLineLength into this.options and update FormatOptions to extend from @herb-tools/printer options
+     */
     maxLineLength;
-    source;
+    /**
+     * @deprecated refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
+     */
     lines = [];
     indentLevel = 0;
     inlineMode = false;
-    isInComplexNesting = false;
+    currentAttributeName = null;
+    elementStack = [];
+    elementFormattingAnalysis = new Map();
+    source;
+    // TODO: extract
     static INLINE_ELEMENTS = new Set([
         'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'cite', 'code',
         'dfn', 'em', 'i', 'img', 'kbd', 'label', 'map', 'object', 'q',
         'samp', 'small', 'span', 'strong', 'sub', 'sup',
         'tt', 'var', 'del', 'ins', 'mark', 's', 'u', 'time', 'wbr'
     ]);
+    static SPACEABLE_CONTAINERS = new Set([
+        'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
+        'figure', 'details', 'summary', 'dialog', 'fieldset'
+    ]);
+    static TIGHT_GROUP_PARENTS = new Set([
+        'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead', 'tbody', 'tfoot'
+    ]);
+    static TIGHT_GROUP_CHILDREN = new Set([
+        'li', 'option', 'td', 'th', 'dt', 'dd'
+    ]);
+    static SPACING_THRESHOLD = 3;
     constructor(source, options) {
         super();
         this.source = source;
         this.indentWidth = options.indentWidth;
         this.maxLineLength = options.maxLineLength;
     }
-    print(object, indentLevel = 0) {
-        if (object instanceof Token || object.type?.startsWith('TOKEN_')) {
-            return object.value;
-        }
-        const node = object;
+    print(input) {
+        if (isToken(input))
+            return input.value;
+        const node = isParseResult(input) ? input.value : input;
+        // TODO: refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
         this.lines = [];
-        this.indentLevel = indentLevel;
-        this.isInComplexNesting = false; // Reset for each top-level element
-        if (typeof node.accept === 'function') {
-            node.accept(this);
+        this.indentLevel = 0;
+        this.visit(node);
+        return this.lines.join("\n");
+    }
+    /**
+     * Get the current element (top of stack)
+     */
+    get currentElement() {
+        return this.elementStack.length > 0 ? this.elementStack[this.elementStack.length - 1] : null;
+    }
+    /**
+     * Get the current tag name from the current element context
+     */
+    get currentTagName() {
+        return this.currentElement?.open_tag?.tag_name?.value ?? "";
+    }
+    /**
+     * Append text to the last line instead of creating a new line
+     */
+    pushToLastLine(text) {
+        if (this.lines.length > 0) {
+            this.lines[this.lines.length - 1] += text;
         }
         else {
-            this.visit(node);
+            this.lines.push(text);
+        }
+    }
+    /**
+     * Capture output from a callback into a separate lines array
+     * Useful for testing what output would be generated without affecting the main output
+     */
+    capture(callback) {
+        const previousLines = this.lines;
+        const previousInlineMode = this.inlineMode;
+        this.lines = [];
+        try {
+            callback();
+            return this.lines;
+        }
+        finally {
+            this.lines = previousLines;
+            this.inlineMode = previousInlineMode;
+        }
+    }
+    /**
+     * Capture all nodes that would be visited during a callback
+     * Returns a flat list of all nodes without generating any output
+     */
+    captureNodes(callback) {
+        const capturedNodes = [];
+        const previousLines = this.lines;
+        const previousInlineMode = this.inlineMode;
+        const originalPush = this.push.bind(this);
+        const originalPushToLastLine = this.pushToLastLine.bind(this);
+        const originalVisit = this.visit.bind(this);
+        this.lines = [];
+        this.push = () => { };
+        this.pushToLastLine = () => { };
+        this.visit = (node) => {
+            capturedNodes.push(node);
+            originalVisit(node);
+        };
+        try {
+            callback();
+            return capturedNodes;
+        }
+        finally {
+            this.lines = previousLines;
+            this.inlineMode = previousInlineMode;
+            this.push = originalPush;
+            this.pushToLastLine = originalPushToLastLine;
+            this.visit = originalVisit;
         }
-        return this.lines.join("\n");
     }
+    /**
+     * @deprecated refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
+     */
     push(line) {
         this.lines.push(line);
     }
@@ -2728,7 +3828,7 @@ class Printer extends Visitor {
         this.indentLevel--;
         return result;
     }
-    indent() {
+    get indent() {
         return " ".repeat(this.indentLevel * this.indentWidth);
     }
     /**
@@ -2738,45 +3838,128 @@ class Printer extends Visitor {
     formatERBContent(content) {
         return content.trim() ? ` ${content.trim()} ` : "";
     }
-    /**
-     * Check if a node is an ERB control flow node (if, unless, block, case, while, for)
-     */
-    isERBControlFlow(node) {
-        return node instanceof ERBIfNode || node.type === 'AST_ERB_IF_NODE' ||
-            node instanceof ERBUnlessNode || node.type === 'AST_ERB_UNLESS_NODE' ||
-            node instanceof ERBBlockNode || node.type === 'AST_ERB_BLOCK_NODE' ||
-            node instanceof ERBCaseNode || node.type === 'AST_ERB_CASE_NODE' ||
-            node instanceof ERBCaseMatchNode || node.type === 'AST_ERB_CASE_MATCH_NODE' ||
-            node instanceof ERBWhileNode || node.type === 'AST_ERB_WHILE_NODE' ||
-            node instanceof ERBForNode || node.type === 'AST_ERB_FOR_NODE';
-    }
     /**
      * Count total attributes including those inside ERB conditionals
      */
     getTotalAttributeCount(attributes, inlineNodes = []) {
         let totalAttributeCount = attributes.length;
         inlineNodes.forEach(node => {
-            if (this.isERBControlFlow(node)) {
-                const erbNode = node;
-                if (erbNode.statements) {
-                    totalAttributeCount += erbNode.statements.length;
-                }
+            if (isERBControlFlowNode(node)) {
+                const capturedNodes = this.captureNodes(() => this.visit(node));
+                const attributeNodes = filterNodes(capturedNodes, HTMLAttributeNode);
+                totalAttributeCount += attributeNodes.length;
             }
         });
         return totalAttributeCount;
     }
     /**
-     * Extract HTML attributes from a list of nodes
+     * Extract inline nodes (non-attribute, non-whitespace) from a list of nodes
+     */
+    extractInlineNodes(nodes) {
+        return nodes.filter(child => isNoneOf(child, HTMLAttributeNode, WhitespaceNode));
+    }
+    /**
+     * Determine if spacing should be added between sibling elements
+     *
+     * This implements the "rule of three" intelligent spacing system:
+     * - Adds spacing between 3 or more meaningful siblings
+     * - Respects semantic groupings (e.g., ul/li, nav/a stay tight)
+     * - Groups comments with following elements
+     * - Preserves user-added spacing
+     *
+     * @param parentElement - The parent element containing the siblings
+     * @param siblings - Array of all sibling nodes
+     * @param currentIndex - Index of the current node being evaluated
+     * @param hasExistingSpacing - Whether user-added spacing already exists
+     * @returns true if spacing should be added before the current element
      */
-    extractAttributes(nodes) {
-        return nodes.filter((child) => child instanceof HTMLAttributeNode || child.type === 'AST_HTML_ATTRIBUTE_NODE');
+    shouldAddSpacingBetweenSiblings(parentElement, siblings, currentIndex, hasExistingSpacing) {
+        if (hasExistingSpacing) {
+            return true;
+        }
+        const hasMixedContent = siblings.some(child => isNode(child, HTMLTextNode) && child.content.trim() !== "");
+        if (hasMixedContent) {
+            return false;
+        }
+        const meaningfulSiblings = siblings.filter(child => this.isNonWhitespaceNode(child));
+        if (meaningfulSiblings.length < FormatPrinter.SPACING_THRESHOLD) {
+            return false;
+        }
+        const parentTagName = parentElement ? getTagName(parentElement) : null;
+        if (parentTagName && FormatPrinter.TIGHT_GROUP_PARENTS.has(parentTagName)) {
+            return false;
+        }
+        const isSpaceableContainer = !parentTagName || (parentTagName && FormatPrinter.SPACEABLE_CONTAINERS.has(parentTagName));
+        if (!isSpaceableContainer && meaningfulSiblings.length < 5) {
+            return false;
+        }
+        const currentNode = siblings[currentIndex];
+        const previousMeaningfulIndex = this.findPreviousMeaningfulSibling(siblings, currentIndex);
+        const isCurrentComment = isCommentNode(currentNode);
+        if (previousMeaningfulIndex !== -1) {
+            const previousNode = siblings[previousMeaningfulIndex];
+            const isPreviousComment = isCommentNode(previousNode);
+            if (isPreviousComment && !isCurrentComment && (isNode(currentNode, HTMLElementNode) || isERBNode(currentNode))) {
+                return false;
+            }
+            if (isPreviousComment && isCurrentComment) {
+                return false;
+            }
+        }
+        if (isNode(currentNode, HTMLElementNode)) {
+            const currentTagName = getTagName(currentNode);
+            if (FormatPrinter.INLINE_ELEMENTS.has(currentTagName)) {
+                return false;
+            }
+            if (FormatPrinter.TIGHT_GROUP_CHILDREN.has(currentTagName)) {
+                return false;
+            }
+            if (currentTagName === 'a' && parentTagName === 'nav') {
+                return false;
+            }
+        }
+        const isBlockElement = this.isBlockLevelNode(currentNode);
+        const isERBBlock = isERBNode(currentNode) && isERBControlFlowNode(currentNode);
+        const isComment = isCommentNode(currentNode);
+        return isBlockElement || isERBBlock || isComment;
     }
     /**
-     * Extract inline nodes (non-attribute, non-whitespace) from a list of nodes
+     * Token list attributes that contain space-separated values and benefit from
+     * spacing around ERB content for readability
      */
-    extractInlineNodes(nodes) {
-        return nodes.filter(child => !(child instanceof HTMLAttributeNode || child.type === 'AST_HTML_ATTRIBUTE_NODE') &&
-            !(child instanceof WhitespaceNode || child.type === 'AST_WHITESPACE_NODE'));
+    static TOKEN_LIST_ATTRIBUTES = new Set([
+        'class', 'data-controller', 'data-action'
+    ]);
+    /**
+     * Check if we're currently processing a token list attribute that needs spacing
+     */
+    isInTokenListAttribute() {
+        return this.currentAttributeName !== null &&
+            FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName);
+    }
+    /**
+     * Find the previous meaningful (non-whitespace) sibling
+     */
+    findPreviousMeaningfulSibling(siblings, currentIndex) {
+        for (let i = currentIndex - 1; i >= 0; i--) {
+            if (this.isNonWhitespaceNode(siblings[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * Check if a node represents a block-level element
+     */
+    isBlockLevelNode(node) {
+        if (!isNode(node, HTMLElementNode)) {
+            return false;
+        }
+        const tagName = getTagName(node);
+        if (FormatPrinter.INLINE_ELEMENTS.has(tagName)) {
+            return false;
+        }
+        return true;
     }
     /**
      * Render attributes as a space-separated string
@@ -2784,63 +3967,198 @@ class Printer extends Visitor {
     renderAttributesString(attributes) {
         if (attributes.length === 0)
             return "";
-        return ` ${attributes.map(attr => this.renderAttribute(attr)).join(" ")}`;
+        return ` ${attributes.map(attribute => this.renderAttribute(attribute)).join(" ")}`;
     }
     /**
      * Determine if a tag should be rendered inline based on attribute count and other factors
      */
-    shouldRenderInline(totalAttributeCount, inlineLength, indentLength, maxLineLength = this.maxLineLength, hasComplexERB = false, nestingDepth = 0, inlineNodesLength = 0) {
-        if (hasComplexERB)
+    shouldRenderInline(totalAttributeCount, inlineLength, indentLength, maxLineLength = this.maxLineLength, hasComplexERB = false, hasMultilineAttributes = false, attributes = []) {
+        if (hasComplexERB || hasMultilineAttributes)
             return false;
-        // Special case: no attributes at all, always inline if it fits
         if (totalAttributeCount === 0) {
             return inlineLength + indentLength <= maxLineLength;
         }
-        const basicInlineCondition = totalAttributeCount <= 3 &&
-            inlineLength + indentLength <= maxLineLength;
-        const erbInlineCondition = inlineNodesLength > 0 && totalAttributeCount <= 3;
-        return basicInlineCondition || erbInlineCondition;
+        if (totalAttributeCount === 1 && attributes.length === 1) {
+            const attribute = attributes[0];
+            const attributeName = this.getAttributeName(attribute);
+            if (attributeName === 'class') {
+                const attributeValue = this.getAttributeValue(attribute);
+                const wouldBeMultiline = this.wouldClassAttributeBeMultiline(attributeValue, indentLength);
+                if (!wouldBeMultiline) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        if (totalAttributeCount > 3 || inlineLength + indentLength > maxLineLength) {
+            return false;
+        }
+        return true;
+    }
+    getAttributeName(attribute) {
+        return attribute.name ? getCombinedAttributeName(attribute.name) : "";
+    }
+    wouldClassAttributeBeMultiline(content, indentLength) {
+        const normalizedContent = content.replace(/\s+/g, ' ').trim();
+        const hasActualNewlines = /\r?\n/.test(content);
+        if (hasActualNewlines && normalizedContent.length > 80) {
+            const lines = content.split(/\r?\n/).map(line => line.trim()).filter(line => line);
+            if (lines.length > 1) {
+                return true;
+            }
+        }
+        const attributeLine = `class="${normalizedContent}"`;
+        const currentIndent = indentLength;
+        if (currentIndent + attributeLine.length > this.maxLineLength && normalizedContent.length > 60) {
+            if (/<%[^%]*%>/.test(normalizedContent)) {
+                return false;
+            }
+            const classes = normalizedContent.split(' ');
+            const lines = this.breakTokensIntoLines(classes, currentIndent);
+            return lines.length > 1;
+        }
+        return false;
+    }
+    getAttributeValue(attribute) {
+        if (attribute.value && isNode(attribute.value, HTMLAttributeValueNode)) {
+            const content = attribute.value.children.map(child => {
+                if (isNode(child, HTMLTextNode)) {
+                    return child.content;
+                }
+                return IdentityPrinter.print(child);
+            }).join('');
+            return content;
+        }
+        return '';
+    }
+    hasMultilineAttributes(attributes) {
+        return attributes.some(attribute => {
+            if (attribute.value && isNode(attribute.value, HTMLAttributeValueNode)) {
+                const content = getCombinedStringFromNodes(attribute.value.children);
+                if (/\r?\n/.test(content)) {
+                    const name = attribute.name ? getCombinedAttributeName(attribute.name) : "";
+                    if (name === "class") {
+                        const normalizedContent = content.replace(/\s+/g, ' ').trim();
+                        return normalizedContent.length > 80;
+                    }
+                    const lines = content.split(/\r?\n/);
+                    if (lines.length > 1) {
+                        return lines.slice(1).some(line => /^\s+/.test(line));
+                    }
+                }
+            }
+            return false;
+        });
+    }
+    formatClassAttribute(content, name, equals, open_quote, close_quote) {
+        const normalizedContent = content.replace(/\s+/g, ' ').trim();
+        const hasActualNewlines = /\r?\n/.test(content);
+        if (hasActualNewlines && normalizedContent.length > 80) {
+            const lines = content.split(/\r?\n/).map(line => line.trim()).filter(line => line);
+            if (lines.length > 1) {
+                return open_quote + this.formatMultilineAttributeValue(lines) + close_quote;
+            }
+        }
+        const currentIndent = this.indentLevel * this.indentWidth;
+        const attributeLine = `${name}${equals}${open_quote}${normalizedContent}${close_quote}`;
+        if (currentIndent + attributeLine.length > this.maxLineLength && normalizedContent.length > 60) {
+            if (/<%[^%]*%>/.test(normalizedContent)) {
+                return open_quote + normalizedContent + close_quote;
+            }
+            const classes = normalizedContent.split(' ');
+            const lines = this.breakTokensIntoLines(classes, currentIndent);
+            if (lines.length > 1) {
+                return open_quote + this.formatMultilineAttributeValue(lines) + close_quote;
+            }
+        }
+        return open_quote + normalizedContent + close_quote;
+    }
+    isFormattableAttribute(attributeName, tagName) {
+        const globalFormattable = FORMATTABLE_ATTRIBUTES['*'] || [];
+        const tagSpecificFormattable = FORMATTABLE_ATTRIBUTES[tagName.toLowerCase()] || [];
+        return globalFormattable.includes(attributeName) || tagSpecificFormattable.includes(attributeName);
+    }
+    formatMultilineAttribute(content, name, open_quote, close_quote) {
+        if (name === 'srcset' || name === 'sizes') {
+            const normalizedContent = content.replace(/\s+/g, ' ').trim();
+            return open_quote + normalizedContent + close_quote;
+        }
+        const lines = content.split('\n');
+        if (lines.length <= 1) {
+            return open_quote + content + close_quote;
+        }
+        const formattedContent = this.formatMultilineAttributeValue(lines);
+        return open_quote + formattedContent + close_quote;
+    }
+    formatMultilineAttributeValue(lines) {
+        const indent = " ".repeat((this.indentLevel + 1) * this.indentWidth);
+        const closeIndent = " ".repeat(this.indentLevel * this.indentWidth);
+        return "\n" + lines.map(line => indent + line).join("\n") + "\n" + closeIndent;
+    }
+    breakTokensIntoLines(tokens, currentIndent, separator = ' ') {
+        const lines = [];
+        let currentLine = '';
+        for (const token of tokens) {
+            const testLine = currentLine ? currentLine + separator + token : token;
+            if (testLine.length > (this.maxLineLength - currentIndent - 6)) {
+                if (currentLine) {
+                    lines.push(currentLine);
+                    currentLine = token;
+                }
+                else {
+                    lines.push(token);
+                }
+            }
+            else {
+                currentLine = testLine;
+            }
+        }
+        if (currentLine)
+            lines.push(currentLine);
+        return lines;
     }
     /**
      * Render multiline attributes for a tag
      */
-    renderMultilineAttributes(tagName, attributes, inlineNodes = [], allChildren = [], isSelfClosing = false, isVoid = false, hasBodyContent = false) {
-        const indent = this.indent();
-        this.push(indent + `<${tagName}`);
+    renderMultilineAttributes(tagName, allChildren = [], isSelfClosing = false) {
+        this.push(this.indent + `<${tagName}`);
         this.withIndent(() => {
-            // Render children in order, handling both attributes and ERB nodes
             allChildren.forEach(child => {
-                if (child instanceof HTMLAttributeNode || child.type === 'AST_HTML_ATTRIBUTE_NODE') {
-                    this.push(this.indent() + this.renderAttribute(child));
+                if (isNode(child, HTMLAttributeNode)) {
+                    this.push(this.indent + this.renderAttribute(child));
                 }
-                else if (!(child instanceof WhitespaceNode || child.type === 'AST_WHITESPACE_NODE')) {
+                else if (!isNode(child, WhitespaceNode)) {
                     this.visit(child);
                 }
             });
         });
         if (isSelfClosing) {
-            this.push(indent + "/>");
-        }
-        else if (isVoid) {
-            this.push(indent + ">");
-        }
-        else if (!hasBodyContent) {
-            this.push(indent + `></${tagName}>`);
+            this.push(this.indent + "/>");
         }
         else {
-            this.push(indent + ">");
+            this.push(this.indent + ">");
         }
     }
     /**
-     * Print an ERB tag (<% %> or <%= %>) with single spaces around inner content.
+     * Reconstruct the text representation of an ERB node
+     * @param withFormatting - if true, format the content; if false, preserve original
      */
-    printERBNode(node) {
-        const indent = this.inlineMode ? "" : this.indent();
+    reconstructERBNode(node, withFormatting = true) {
         const open = node.tag_opening?.value ?? "";
         const close = node.tag_closing?.value ?? "";
         const content = node.content?.value ?? "";
-        const inner = this.formatERBContent(content);
-        this.push(indent + open + inner + close);
+        const inner = withFormatting ? this.formatERBContent(content) : content;
+        return open + inner + close;
+    }
+    /**
+     * Print an ERB tag (<% %> or <%= %>) with single spaces around inner content.
+     */
+    printERBNode(node) {
+        const indent = this.inlineMode ? "" : this.indent;
+        const erbText = this.reconstructERBNode(node, true);
+        this.push(indent + erbText);
     }
     // --- Visitor methods ---
     visitDocumentNode(node) {
@@ -2848,14 +4166,13 @@ class Printer extends Visitor {
         let hasHandledSpacing = false;
         for (let i = 0; i < node.children.length; i++) {
             const child = node.children[i];
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                const textNode = child;
-                const isWhitespaceOnly = textNode.content.trim() === "";
+            if (isNode(child, HTMLTextNode)) {
+                const isWhitespaceOnly = child.content.trim() === "";
                 if (isWhitespaceOnly) {
-                    const hasPrevNonWhitespace = i > 0 && this.isNonWhitespaceNode(node.children[i - 1]);
+                    const hasPreviousNonWhitespace = i > 0 && this.isNonWhitespaceNode(node.children[i - 1]);
                     const hasNextNonWhitespace = i < node.children.length - 1 && this.isNonWhitespaceNode(node.children[i + 1]);
-                    const hasMultipleNewlines = textNode.content.includes('\n\n');
-                    if (hasPrevNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
+                    const hasMultipleNewlines = child.content.includes('\n\n');
+                    if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
                         this.push("");
                         hasHandledSpacing = true;
                     }
@@ -2873,326 +4190,145 @@ class Printer extends Visitor {
         }
     }
     visitHTMLElementNode(node) {
-        const open = node.open_tag;
-        const tagName = open.tag_name?.value ?? "";
-        const indent = this.indent();
-        const attributes = this.extractAttributes(open.children);
-        const inlineNodes = this.extractInlineNodes(open.children);
-        const hasTextFlow = this.isInTextFlowContext(null, node.body);
-        const children = node.body.filter(child => {
-            if (child instanceof WhitespaceNode || child.type === 'AST_WHITESPACE_NODE') {
-                return false;
-            }
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                const content = child.content;
-                if (hasTextFlow && content === " ") {
-                    return true;
-                }
-                return content.trim() !== "";
-            }
-            return true;
-        });
-        const isInlineElement = this.isInlineElement(tagName);
-        const hasClosing = open.tag_closing?.value === ">" || open.tag_closing?.value === "/>";
-        const isSelfClosing = open.tag_closing?.value === "/>";
-        if (!hasClosing) {
-            this.push(indent + `<${tagName}`);
-            return;
+        this.elementStack.push(node);
+        this.elementFormattingAnalysis.set(node, this.analyzeElementFormatting(node));
+        this.visit(node.open_tag);
+        if (node.body.length > 0) {
+            this.visitHTMLElementBody(node.body, node);
         }
-        if (attributes.length === 0 && inlineNodes.length === 0) {
-            if (children.length === 0) {
-                if (isSelfClosing) {
-                    this.push(indent + `<${tagName} />`);
-                }
-                else if (node.is_void) {
-                    this.push(indent + `<${tagName}>`);
-                }
-                else {
-                    this.push(indent + `<${tagName}></${tagName}>`);
-                }
+        if (node.close_tag) {
+            this.visit(node.close_tag);
+        }
+        this.elementStack.pop();
+    }
+    visitHTMLElementBody(body, element) {
+        const analysis = this.elementFormattingAnalysis.get(element);
+        const hasTextFlow = this.isInTextFlowContext(null, body);
+        const children = this.filterSignificantChildren(body, hasTextFlow);
+        if (analysis?.elementContentInline) {
+            if (children.length === 0)
                 return;
-            }
-            if (children.length >= 1) {
-                if (this.isInComplexNesting) {
-                    if (children.length === 1) {
-                        const child = children[0];
-                        if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                            const textContent = child.content.trim();
-                            const singleLine = `<${tagName}>${textContent}</${tagName}>`;
-                            if (!textContent.includes('\n') && (indent.length + singleLine.length) <= this.maxLineLength) {
-                                this.push(indent + singleLine);
-                                return;
-                            }
-                        }
-                    }
-                }
-                else {
-                    const inlineResult = this.tryRenderInline(children, tagName, 0, false, hasTextFlow);
-                    if (inlineResult && (indent.length + inlineResult.length) <= this.maxLineLength) {
-                        this.push(indent + inlineResult);
-                        return;
-                    }
-                    if (hasTextFlow) {
-                        const hasAnyNewlines = children.some(child => {
-                            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                                return child.content.includes('\n');
+            const oldInlineMode = this.inlineMode;
+            const nodesToRender = hasTextFlow ? body : children;
+            this.inlineMode = true;
+            const lines = this.capture(() => {
+                nodesToRender.forEach(child => {
+                    if (isNode(child, HTMLTextNode)) {
+                        if (hasTextFlow) {
+                            const normalizedContent = child.content.replace(/\s+/g, ' ');
+                            if (normalizedContent && normalizedContent !== ' ') {
+                                this.push(normalizedContent);
                             }
-                            return false;
-                        });
-                        if (!hasAnyNewlines) {
-                            const fullInlineResult = this.tryRenderInlineFull(node, tagName, attributes, children);
-                            if (fullInlineResult) {
-                                const totalLength = indent.length + fullInlineResult.length;
-                                const maxNesting = this.getMaxNestingDepth(children, 0);
-                                const maxInlineLength = maxNesting <= 1 ? this.maxLineLength : 60;
-                                if (totalLength <= maxInlineLength) {
-                                    this.push(indent + fullInlineResult);
-                                    return;
-                                }
+                            else if (normalizedContent === ' ') {
+                                this.push(' ');
                             }
                         }
-                    }
-                }
-            }
-            if (hasTextFlow) {
-                const fullInlineResult = this.tryRenderInlineFull(node, tagName, [], children);
-                if (fullInlineResult) {
-                    const totalLength = indent.length + fullInlineResult.length;
-                    const maxNesting = this.getMaxNestingDepth(children, 0);
-                    const maxInlineLength = maxNesting <= 1 ? this.maxLineLength : 60;
-                    if (totalLength <= maxInlineLength) {
-                        this.push(indent + fullInlineResult);
-                        return;
-                    }
-                }
-            }
-            this.push(indent + `<${tagName}>`);
-            this.withIndent(() => {
-                if (hasTextFlow) {
-                    this.visitTextFlowChildren(children);
-                }
-                else {
-                    children.forEach(child => this.visit(child));
-                }
-            });
-            if (!node.is_void && !isSelfClosing) {
-                this.push(indent + `</${tagName}>`);
-            }
-            return;
-        }
-        if (attributes.length === 0 && inlineNodes.length > 0) {
-            const inline = this.renderInlineOpen(tagName, [], isSelfClosing, inlineNodes, open.children);
-            if (children.length === 0) {
-                if (isSelfClosing || node.is_void) {
-                    this.push(indent + inline);
-                }
-                else {
-                    this.push(indent + inline + `</${tagName}>`);
-                }
-                return;
-            }
-            this.push(indent + inline);
-            this.withIndent(() => {
-                children.forEach(child => this.visit(child));
-            });
-            if (!node.is_void && !isSelfClosing) {
-                this.push(indent + `</${tagName}>`);
-            }
-            return;
-        }
-        const hasERBControlFlow = inlineNodes.some(node => this.isERBControlFlow(node)) ||
-            open.children.some(node => this.isERBControlFlow(node));
-        const hasComplexERB = hasERBControlFlow && inlineNodes.some(node => {
-            if (node instanceof ERBIfNode || node.type === 'AST_ERB_IF_NODE') {
-                const erbNode = node;
-                if (erbNode.statements.length > 0 && erbNode.location) {
-                    const startLine = erbNode.location.start.line;
-                    const endLine = erbNode.location.end.line;
-                    return startLine !== endLine;
-                }
-                return false;
-            }
-            return false;
-        });
-        const inline = hasComplexERB ? "" : this.renderInlineOpen(tagName, attributes, isSelfClosing, inlineNodes, open.children);
-        const nestingDepth = this.getMaxNestingDepth(children, 0);
-        const totalAttributeCount = this.getTotalAttributeCount(attributes, inlineNodes);
-        const shouldKeepInline = this.shouldRenderInline(totalAttributeCount, inline.length, indent.length, this.maxLineLength, hasComplexERB, nestingDepth, inlineNodes.length);
-        if (shouldKeepInline) {
-            if (children.length === 0) {
-                if (isSelfClosing) {
-                    this.push(indent + inline);
-                }
-                else if (node.is_void) {
-                    this.push(indent + inline);
-                }
-                else {
-                    let result = `<${tagName}`;
-                    result += this.renderAttributesString(attributes);
-                    if (inlineNodes.length > 0) {
-                        const currentIndentLevel = this.indentLevel;
-                        this.indentLevel = 0;
-                        const tempLines = this.lines;
-                        this.lines = [];
-                        inlineNodes.forEach(node => {
-                            const wasInlineMode = this.inlineMode;
-                            if (!this.isERBControlFlow(node)) {
-                                this.inlineMode = true;
+                        else {
+                            const normalizedContent = child.content.replace(/\s+/g, ' ').trim();
+                            if (normalizedContent) {
+                                this.push(normalizedContent);
                             }
-                            this.visit(node);
-                            this.inlineMode = wasInlineMode;
-                        });
-                        const inlineContent = this.lines.join("");
-                        this.lines = tempLines;
-                        this.indentLevel = currentIndentLevel;
-                        result += inlineContent;
+                        }
                     }
-                    result += `></${tagName}>`;
-                    this.push(indent + result);
-                }
-                return;
-            }
-            if (isInlineElement && children.length > 0 && !hasERBControlFlow) {
-                const fullInlineResult = this.tryRenderInlineFull(node, tagName, attributes, children);
-                if (fullInlineResult) {
-                    const totalLength = indent.length + fullInlineResult.length;
-                    if (totalLength <= this.maxLineLength || totalLength <= 120) {
-                        this.push(indent + fullInlineResult);
+                    else if (isNode(child, WhitespaceNode)) {
                         return;
                     }
-                }
-            }
-            if (!isInlineElement && children.length > 0 && !hasERBControlFlow) {
-                this.push(indent + inline);
-                this.withIndent(() => {
-                    if (hasTextFlow) {
-                        this.visitTextFlowChildren(children);
-                    }
                     else {
-                        children.forEach(child => this.visit(child));
+                        this.visit(child);
                     }
                 });
-                if (!node.is_void && !isSelfClosing) {
-                    this.push(indent + `</${tagName}>`);
-                }
-                return;
-            }
-            if (isSelfClosing) {
-                this.push(indent + inline.replace(' />', '>'));
-            }
-            else {
-                this.push(indent + inline);
-            }
-            this.withIndent(() => {
-                if (hasTextFlow) {
-                    this.visitTextFlowChildren(children);
-                }
-                else {
-                    children.forEach(child => this.visit(child));
-                }
             });
-            if (!node.is_void && !isSelfClosing) {
-                this.push(indent + `</${tagName}>`);
+            const content = lines.join('');
+            const inlineContent = hasTextFlow ? content.replace(/\s+/g, ' ').trim() : content.trim();
+            if (inlineContent) {
+                this.pushToLastLine(inlineContent);
             }
+            this.inlineMode = oldInlineMode;
             return;
         }
-        if (inlineNodes.length > 0 && hasERBControlFlow) {
-            this.renderMultilineAttributes(tagName, attributes, inlineNodes, open.children, isSelfClosing, node.is_void, children.length > 0);
-            if (!isSelfClosing && !node.is_void && children.length > 0) {
-                this.withIndent(() => {
-                    children.forEach(child => this.visit(child));
-                });
-                this.push(indent + `</${tagName}>`);
+        if (children.length === 0)
+            return;
+        this.withIndent(() => {
+            if (hasTextFlow) {
+                this.visitTextFlowChildren(children);
             }
-        }
-        else if (inlineNodes.length > 0) {
-            this.push(indent + this.renderInlineOpen(tagName, attributes, isSelfClosing, inlineNodes, open.children));
-            if (!isSelfClosing && !node.is_void && children.length > 0) {
-                this.withIndent(() => {
-                    children.forEach(child => this.visit(child));
-                });
-                this.push(indent + `</${tagName}>`);
+            else {
+                this.visitElementChildren(body, element);
             }
-        }
-        else {
-            if (isInlineElement && children.length > 0) {
-                const fullInlineResult = this.tryRenderInlineFull(node, tagName, attributes, children);
-                if (fullInlineResult) {
-                    const totalLength = indent.length + fullInlineResult.length;
-                    if (totalLength <= this.maxLineLength || totalLength <= 120) {
-                        this.push(indent + fullInlineResult);
-                        return;
+        });
+    }
+    /**
+     * Visit element children with intelligent spacing logic
+     */
+    visitElementChildren(body, parentElement) {
+        let lastWasMeaningful = false;
+        let hasHandledSpacing = false;
+        for (let i = 0; i < body.length; i++) {
+            const child = body[i];
+            if (isNode(child, HTMLTextNode)) {
+                const isWhitespaceOnly = child.content.trim() === "";
+                if (isWhitespaceOnly) {
+                    const hasPreviousNonWhitespace = i > 0 && this.isNonWhitespaceNode(body[i - 1]);
+                    const hasNextNonWhitespace = i < body.length - 1 && this.isNonWhitespaceNode(body[i + 1]);
+                    const hasMultipleNewlines = child.content.includes('\n\n');
+                    if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
+                        this.push("");
+                        hasHandledSpacing = true;
                     }
+                    continue;
                 }
             }
-            if (isInlineElement && children.length === 0) {
-                let result = `<${tagName}`;
-                result += this.renderAttributesString(attributes);
-                if (isSelfClosing) {
-                    result += " />";
-                }
-                else if (node.is_void) {
-                    result += ">";
-                }
-                else {
-                    result += `></${tagName}>`;
+            if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+                const element = body[i - 1];
+                const hasExistingSpacing = i > 0 && isNode(element, HTMLTextNode) && element.content.trim() === "" && (element.content.includes('\n\n') || element.content.split('\n').length > 2);
+                const shouldAddSpacing = this.shouldAddSpacingBetweenSiblings(parentElement, body, i, hasExistingSpacing);
+                if (shouldAddSpacing) {
+                    this.push("");
                 }
-                this.push(indent + result);
-                return;
             }
-            this.renderMultilineAttributes(tagName, attributes, inlineNodes, open.children, isSelfClosing, node.is_void, children.length > 0);
-            if (!isSelfClosing && !node.is_void && children.length > 0) {
-                this.withIndent(() => {
-                    if (hasTextFlow) {
-                        this.visitTextFlowChildren(children);
-                    }
-                    else {
-                        children.forEach(child => this.visit(child));
-                    }
-                });
-                this.push(indent + `</${tagName}>`);
+            this.visit(child);
+            if (this.isNonWhitespaceNode(child)) {
+                lastWasMeaningful = true;
+                hasHandledSpacing = false;
             }
         }
     }
     visitHTMLOpenTagNode(node) {
-        const tagName = node.tag_name?.value ?? "";
-        const indent = this.indent();
-        const attributes = this.extractAttributes(node.children);
+        const attributes = filterNodes(node.children, HTMLAttributeNode);
         const inlineNodes = this.extractInlineNodes(node.children);
-        const hasClosing = node.tag_closing?.value === ">";
-        if (!hasClosing) {
-            this.push(indent + `<${tagName}`);
-            return;
+        const isSelfClosing = node.tag_closing?.value === "/>";
+        if (this.currentElement && this.elementFormattingAnalysis.has(this.currentElement)) {
+            const analysis = this.elementFormattingAnalysis.get(this.currentElement);
+            if (analysis.openTagInline) {
+                const inline = this.renderInlineOpen(getTagName(node), attributes, isSelfClosing, inlineNodes, node.children);
+                this.push(this.inlineMode ? inline : this.indent + inline);
+                return;
+            }
+            else {
+                this.renderMultilineAttributes(getTagName(node), node.children, isSelfClosing);
+                return;
+            }
         }
-        const inline = this.renderInlineOpen(tagName, attributes, node.is_void, inlineNodes, node.children);
+        const inline = this.renderInlineOpen(getTagName(node), attributes, isSelfClosing, inlineNodes, node.children);
         const totalAttributeCount = this.getTotalAttributeCount(attributes, inlineNodes);
-        const shouldKeepInline = this.shouldRenderInline(totalAttributeCount, inline.length, indent.length, this.maxLineLength, false, 0, inlineNodes.length);
+        const shouldKeepInline = this.shouldRenderInline(totalAttributeCount, inline.length, this.indent.length, this.maxLineLength, false, this.hasMultilineAttributes(attributes), attributes);
         if (shouldKeepInline) {
-            this.push(indent + inline);
-            return;
+            this.push(this.inlineMode ? inline : this.indent + inline);
         }
-        this.renderMultilineAttributes(tagName, attributes, inlineNodes, node.children, false, node.is_void, false);
-    }
-    visitHTMLSelfCloseTagNode(node) {
-        const tagName = node.tag_name?.value ?? "";
-        const indent = this.indent();
-        const attributes = this.extractAttributes(node.attributes);
-        const inlineNodes = this.extractInlineNodes(node.attributes);
-        const inline = this.renderInlineOpen(tagName, attributes, true, inlineNodes, node.attributes);
-        const totalAttributeCount = this.getTotalAttributeCount(attributes, inlineNodes);
-        const shouldKeepInline = this.shouldRenderInline(totalAttributeCount, inline.length, indent.length, this.maxLineLength, false, 0, inlineNodes.length);
-        if (shouldKeepInline) {
-            this.push(indent + inline);
-            return;
+        else {
+            this.renderMultilineAttributes(getTagName(node), node.children, isSelfClosing);
         }
-        this.renderMultilineAttributes(tagName, attributes, inlineNodes, node.attributes, true, false, false);
     }
     visitHTMLCloseTagNode(node) {
-        const indent = this.indent();
-        const open = node.tag_opening?.value ?? "";
-        const name = node.tag_name?.value ?? "";
-        const close = node.tag_closing?.value ?? "";
-        this.push(indent + open + name + close);
+        const closingTag = IdentityPrinter.print(node);
+        const analysis = this.currentElement && this.elementFormattingAnalysis.get(this.currentElement);
+        const closeTagInline = analysis?.closeTagInline;
+        if (this.currentElement && closeTagInline) {
+            this.pushToLastLine(closingTag);
+        }
+        else {
+            this.push(this.indent + closingTag);
+        }
     }
     visitHTMLTextNode(node) {
         if (this.inlineMode) {
@@ -3202,17 +4338,16 @@ class Printer extends Visitor {
             }
             return;
         }
-        const indent = this.indent();
         let text = node.content.trim();
         if (!text)
             return;
-        const wrapWidth = this.maxLineLength - indent.length;
+        const wrapWidth = this.maxLineLength - this.indent.length;
         const words = text.split(/\s+/);
         const lines = [];
         let line = "";
         for (const word of words) {
             if ((line + (line ? " " : "") + word).length > wrapWidth && line) {
-                lines.push(indent + line);
+                lines.push(this.indent + line);
                 line = word;
             }
             else {
@@ -3220,68 +4355,82 @@ class Printer extends Visitor {
             }
         }
         if (line)
-            lines.push(indent + line);
+            lines.push(this.indent + line);
         lines.forEach(line => this.push(line));
     }
     visitHTMLAttributeNode(node) {
-        const indent = this.indent();
-        this.push(indent + this.renderAttribute(node));
+        this.push(this.indent + this.renderAttribute(node));
     }
     visitHTMLAttributeNameNode(node) {
-        const indent = this.indent();
-        const name = node.name?.value ?? "";
-        this.push(indent + name);
+        this.push(this.indent + getCombinedAttributeName(node));
     }
     visitHTMLAttributeValueNode(node) {
-        const indent = this.indent();
-        const open_quote = node.open_quote?.value ?? "";
-        const close_quote = node.close_quote?.value ?? "";
-        const attribute_value = node.children.map(child => {
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE' ||
-                child instanceof LiteralNode || child.type === 'AST_LITERAL_NODE') {
-                return child.content;
-            }
-            else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
-                const erbChild = child;
-                return (erbChild.tag_opening.value + erbChild.content.value + erbChild.tag_closing.value);
-            }
-            return "";
-        }).join("");
-        this.push(indent + open_quote + attribute_value + close_quote);
+        this.push(this.indent + IdentityPrinter.print(node));
     }
+    // TODO: rework
     visitHTMLCommentNode(node) {
-        const indent = this.indent();
         const open = node.comment_start?.value ?? "";
         const close = node.comment_end?.value ?? "";
         let inner;
-        if (node.comment_start && node.comment_end) {
-            // TODO: use .value
-            const [_, startIndex] = node.comment_start.range.toArray();
-            const [endIndex] = node.comment_end.range.toArray();
-            const rawInner = this.source.slice(startIndex, endIndex);
-            inner = ` ${rawInner.trim()} `;
-        }
-        else {
+        if (node.children && node.children.length > 0) {
             inner = node.children.map(child => {
-                const prevLines = this.lines.length;
-                this.visit(child);
-                return this.lines.slice(prevLines).join("");
+                if (isNode(child, HTMLTextNode) || isNode(child, LiteralNode)) {
+                    return child.content;
+                }
+                else if (isERBNode(child) || isNode(child, ERBContentNode)) {
+                    return this.reconstructERBNode(child, false);
+                }
+                else {
+                    return "";
+                }
             }).join("");
+            const hasNewlines = inner.includes('\n');
+            if (hasNewlines) {
+                const lines = inner.split('\n');
+                const childIndent = " ".repeat(this.indentWidth);
+                const firstLineHasContent = lines[0].trim() !== '';
+                if (firstLineHasContent && lines.length > 1) {
+                    const contentLines = lines.map(line => line.trim()).filter(line => line !== '');
+                    inner = '\n' + contentLines.map(line => childIndent + line).join('\n') + '\n';
+                }
+                else {
+                    const contentLines = lines.filter((line, index) => {
+                        return line.trim() !== '' && !(index === 0 || index === lines.length - 1);
+                    });
+                    const minIndent = contentLines.length > 0 ? Math.min(...contentLines.map(line => line.length - line.trimStart().length)) : 0;
+                    const processedLines = lines.map((line, index) => {
+                        const trimmedLine = line.trim();
+                        if ((index === 0 || index === lines.length - 1) && trimmedLine === '') {
+                            return line;
+                        }
+                        if (trimmedLine !== '') {
+                            const currentIndent = line.length - line.trimStart().length;
+                            const relativeIndent = Math.max(0, currentIndent - minIndent);
+                            return childIndent + " ".repeat(relativeIndent) + trimmedLine;
+                        }
+                        return line;
+                    });
+                    inner = processedLines.join('\n');
+                }
+            }
+            else {
+                inner = ` ${inner.trim()} `;
+            }
+        }
+        else {
+            inner = "";
         }
-        this.push(indent + open + inner + close);
+        this.push(this.indent + open + inner + close);
     }
     visitERBCommentNode(node) {
-        const indent = this.indent();
         const open = node.tag_opening?.value ?? "";
         const close = node.tag_closing?.value ?? "";
         let inner;
-        if (node.tag_opening && node.tag_closing) {
-            const [, openingEnd] = node.tag_opening.range.toArray();
-            const [closingStart] = node.tag_closing.range.toArray();
-            const rawInner = this.source.slice(openingEnd, closingStart);
+        if (node.content && node.content.value) {
+            const rawInner = node.content.value;
             const lines = rawInner.split("\n");
             if (lines.length > 2) {
-                const childIndent = indent + " ".repeat(this.indentWidth);
+                const childIndent = this.indent + " ".repeat(this.indentWidth);
                 const innerLines = lines.slice(1, -1).map(line => childIndent + line.trim());
                 inner = "\n" + innerLines.join("\n") + "\n";
             }
@@ -3290,33 +4439,18 @@ class Printer extends Visitor {
             }
         }
         else {
-            inner = node.children
-                .map((child) => {
-                const prevLines = this.lines.length;
-                this.visit(child);
-                return this.lines.slice(prevLines).join("");
-            })
-                .join("");
+            inner = "";
         }
-        this.push(indent + open + inner + close);
+        this.push(this.indent + open + inner + close);
     }
     visitHTMLDoctypeNode(node) {
-        const indent = this.indent();
-        const open = node.tag_opening?.value ?? "";
-        let innerDoctype;
-        if (node.tag_opening && node.tag_closing) {
-            // TODO: use .value
-            const [, openingEnd] = node.tag_opening.range.toArray();
-            const [closingStart] = node.tag_closing.range.toArray();
-            innerDoctype = this.source.slice(openingEnd, closingStart);
-        }
-        else {
-            innerDoctype = node.children
-                .map(child => child instanceof HTMLTextNode ? child.content : (() => { const prevLines = this.lines.length; this.visit(child); return this.lines.slice(prevLines).join(""); })())
-                .join("");
-        }
-        const close = node.tag_closing?.value ?? "";
-        this.push(indent + open + innerDoctype + close);
+        this.push(this.indent + IdentityPrinter.print(node));
+    }
+    visitXMLDeclarationNode(node) {
+        this.push(this.indent + IdentityPrinter.print(node));
+    }
+    visitCDATANode(node) {
+        this.push(this.indent + IdentityPrinter.print(node));
     }
     visitERBContentNode(node) {
         // TODO: this feels hacky
@@ -3335,109 +4469,81 @@ class Printer extends Visitor {
     }
     visitERBInNode(node) {
         this.printERBNode(node);
-        this.withIndent(() => {
-            node.statements.forEach(stmt => this.visit(stmt));
-        });
+        this.withIndent(() => this.visitAll(node.statements));
     }
     visitERBCaseMatchNode(node) {
         this.printERBNode(node);
-        node.conditions.forEach(condition => this.visit(condition));
+        this.visitAll(node.conditions);
         if (node.else_clause)
             this.visit(node.else_clause);
         if (node.end_node)
             this.visit(node.end_node);
     }
     visitERBBlockNode(node) {
-        const indent = this.indent();
-        const open = node.tag_opening?.value ?? "";
-        const content = node.content?.value ?? "";
-        const close = node.tag_closing?.value ?? "";
-        this.push(indent + open + content + close);
-        this.withIndent(() => {
-            node.body.forEach(child => this.visit(child));
-        });
-        if (node.end_node) {
+        this.printERBNode(node);
+        this.withIndent(() => this.visitElementChildren(node.body, null));
+        if (node.end_node)
             this.visit(node.end_node);
-        }
     }
     visitERBIfNode(node) {
         if (this.inlineMode) {
-            const open = node.tag_opening?.value ?? "";
-            const content = node.content?.value ?? "";
-            const close = node.tag_closing?.value ?? "";
-            const inner = this.formatERBContent(content);
-            this.lines.push(open + inner + close);
-            node.statements.forEach((child, _index) => {
-                this.lines.push(" ");
-                if (child instanceof HTMLAttributeNode || child.type === 'AST_HTML_ATTRIBUTE_NODE') {
+            this.printERBNode(node);
+            node.statements.forEach(child => {
+                if (isNode(child, HTMLAttributeNode)) {
+                    this.lines.push(" ");
                     this.lines.push(this.renderAttribute(child));
                 }
                 else {
+                    const shouldAddSpaces = this.isInTokenListAttribute();
+                    if (shouldAddSpaces) {
+                        this.lines.push(" ");
+                    }
                     this.visit(child);
+                    if (shouldAddSpaces) {
+                        this.lines.push(" ");
+                    }
                 }
             });
-            if (node.statements.length > 0 && node.end_node) {
+            const hasHTMLAttributes = node.statements.some(child => isNode(child, HTMLAttributeNode));
+            const isTokenList = this.isInTokenListAttribute();
+            if ((hasHTMLAttributes || isTokenList) && node.end_node) {
                 this.lines.push(" ");
             }
-            if (node.subsequent) {
-                this.visit(node.subsequent);
-            }
-            if (node.end_node) {
-                const endNode = node.end_node;
-                const endOpen = endNode.tag_opening?.value ?? "";
-                const endContent = endNode.content?.value ?? "";
-                const endClose = endNode.tag_closing?.value ?? "";
-                const endInner = this.formatERBContent(endContent);
-                this.lines.push(endOpen + endInner + endClose);
-            }
+            if (node.subsequent)
+                this.visit(node.end_node);
+            if (node.end_node)
+                this.visit(node.end_node);
         }
         else {
             this.printERBNode(node);
             this.withIndent(() => {
                 node.statements.forEach(child => this.visit(child));
             });
-            if (node.subsequent) {
+            if (node.subsequent)
                 this.visit(node.subsequent);
-            }
-            if (node.end_node) {
-                this.printERBNode(node.end_node);
-            }
+            if (node.end_node)
+                this.visit(node.end_node);
         }
     }
     visitERBElseNode(node) {
         this.printERBNode(node);
-        this.withIndent(() => {
-            node.statements.forEach(child => this.visit(child));
-        });
+        this.withIndent(() => node.statements.forEach(statement => this.visit(statement)));
     }
     visitERBWhenNode(node) {
         this.printERBNode(node);
-        this.withIndent(() => {
-            node.statements.forEach(stmt => this.visit(stmt));
-        });
+        this.withIndent(() => this.visitAll(node.statements));
     }
     visitERBCaseNode(node) {
-        const indent = this.indent();
-        const open = node.tag_opening?.value ?? "";
-        const content = node.content?.value ?? "";
-        const close = node.tag_closing?.value ?? "";
-        this.push(indent + open + content + close);
-        node.conditions.forEach(condition => this.visit(condition));
+        this.printERBNode(node);
+        this.visitAll(node.conditions);
         if (node.else_clause)
             this.visit(node.else_clause);
-        if (node.end_node) {
+        if (node.end_node)
             this.visit(node.end_node);
-        }
     }
     visitERBBeginNode(node) {
-        const indent = this.indent();
-        const open = node.tag_opening?.value ?? "";
-        const content = node.content?.value ?? "";
-        const close = node.tag_closing?.value ?? "";
-        this.push(indent + open + content + close);
-        this.withIndent(() => {
-            node.statements.forEach(statement => this.visit(statement));
-        });
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
         if (node.rescue_clause)
             this.visit(node.rescue_clause);
         if (node.else_clause)
@@ -3448,61 +4554,147 @@ class Printer extends Visitor {
             this.visit(node.end_node);
     }
     visitERBWhileNode(node) {
-        this.visitERBGeneric(node);
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
+        if (node.end_node)
+            this.visit(node.end_node);
     }
     visitERBUntilNode(node) {
-        this.visitERBGeneric(node);
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
+        if (node.end_node)
+            this.visit(node.end_node);
     }
     visitERBForNode(node) {
-        this.visitERBGeneric(node);
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
+        if (node.end_node)
+            this.visit(node.end_node);
     }
     visitERBRescueNode(node) {
-        this.visitERBGeneric(node);
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
     }
     visitERBEnsureNode(node) {
-        this.visitERBGeneric(node);
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
     }
     visitERBUnlessNode(node) {
-        this.visitERBGeneric(node);
-    }
-    // TODO: don't use any
-    visitERBGeneric(node) {
-        const indent = this.indent();
-        const open = node.tag_opening?.value ?? "";
-        const content = node.content?.value ?? "";
-        const close = node.tag_closing?.value ?? "";
-        this.push(indent + open + content + close);
-        this.withIndent(() => {
-            const statements = node.statements ?? node.body ?? node.children ?? [];
-            statements.forEach(statement => this.visit(statement));
-        });
+        this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.statements));
+        if (node.else_clause)
+            this.visit(node.else_clause);
         if (node.end_node)
             this.visit(node.end_node);
     }
+    // --- Element Formatting Analysis Helpers ---
+    /**
+     * Analyzes an HTMLElementNode and returns formatting decisions for all parts
+     */
+    analyzeElementFormatting(node) {
+        const openTagInline = this.shouldRenderOpenTagInline(node);
+        const elementContentInline = this.shouldRenderElementContentInline(node);
+        const closeTagInline = this.shouldRenderCloseTagInline(node, elementContentInline);
+        return {
+            openTagInline,
+            elementContentInline,
+            closeTagInline
+        };
+    }
+    /**
+     * Determines if the open tag should be rendered inline
+     */
+    shouldRenderOpenTagInline(node) {
+        const children = node.open_tag?.children || [];
+        const attributes = filterNodes(children, HTMLAttributeNode);
+        const inlineNodes = this.extractInlineNodes(children);
+        const hasERBControlFlow = inlineNodes.some(node => isERBControlFlowNode(node)) || children.some(node => isERBControlFlowNode(node));
+        const hasComplexERB = hasERBControlFlow && this.hasComplexERBControlFlow(inlineNodes);
+        if (hasComplexERB)
+            return false;
+        const totalAttributeCount = this.getTotalAttributeCount(attributes, inlineNodes);
+        const hasMultilineAttrs = this.hasMultilineAttributes(attributes);
+        if (hasMultilineAttrs)
+            return false;
+        const inline = this.renderInlineOpen(getTagName(node), attributes, node.open_tag?.tag_closing?.value === "/>", inlineNodes, children);
+        return this.shouldRenderInline(totalAttributeCount, inline.length, this.indent.length, this.maxLineLength, hasComplexERB, hasMultilineAttrs, attributes);
+    }
+    /**
+     * Determines if the element content should be rendered inline
+     */
+    shouldRenderElementContentInline(node) {
+        const tagName = getTagName(node);
+        const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body));
+        const isInlineElement = this.isInlineElement(tagName);
+        const openTagInline = this.shouldRenderOpenTagInline(node);
+        if (!openTagInline)
+            return false;
+        if (children.length === 0)
+            return true;
+        if (isInlineElement) {
+            const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children);
+            if (fullInlineResult) {
+                const totalLength = this.indent.length + fullInlineResult.length;
+                return totalLength <= this.maxLineLength || totalLength <= 120;
+            }
+            return false;
+        }
+        const allNestedAreInline = this.areAllNestedElementsInline(children);
+        const hasMultilineText = this.hasMultilineTextContent(children);
+        const hasMixedContent = this.hasMixedTextAndInlineContent(children);
+        if (allNestedAreInline && (!hasMultilineText || hasMixedContent)) {
+            const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children);
+            if (fullInlineResult) {
+                const totalLength = this.indent.length + fullInlineResult.length;
+                if (totalLength <= this.maxLineLength) {
+                    return true;
+                }
+            }
+        }
+        const inlineResult = this.tryRenderInline(children, tagName);
+        if (inlineResult) {
+            const openTagResult = this.renderInlineOpen(tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), false, [], node.open_tag?.children || []);
+            const childrenContent = this.renderChildrenInline(children);
+            const fullLine = openTagResult + childrenContent + `</${tagName}>`;
+            if ((this.indent.length + fullLine.length) <= this.maxLineLength) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Determines if the close tag should be rendered inline (usually follows content decision)
+     */
+    shouldRenderCloseTagInline(node, elementContentInline) {
+        const isSelfClosing = node.open_tag?.tag_closing?.value === "/>";
+        if (isSelfClosing || node.is_void)
+            return true;
+        const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body));
+        if (children.length === 0)
+            return true;
+        return elementContentInline;
+    }
     // --- Utility methods ---
     isNonWhitespaceNode(node) {
-        if (node instanceof HTMLTextNode || node.type === 'AST_HTML_TEXT_NODE') {
-            return node.content.trim() !== "";
-        }
-        if (node instanceof WhitespaceNode || node.type === 'AST_WHITESPACE_NODE') {
+        if (isNode(node, WhitespaceNode))
             return false;
-        }
+        if (isNode(node, HTMLTextNode))
+            return node.content.trim() !== "";
         return true;
     }
     /**
      * Check if an element should be treated as inline based on its tag name
      */
     isInlineElement(tagName) {
-        return Printer.INLINE_ELEMENTS.has(tagName.toLowerCase());
+        return FormatPrinter.INLINE_ELEMENTS.has(tagName.toLowerCase());
     }
     /**
      * Check if we're in a text flow context (parent contains mixed text and inline elements)
      */
     visitTextFlowChildren(children) {
-        const indent = this.indent();
         let currentLineContent = "";
         for (const child of children) {
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
+            if (isNode(child, HTMLTextNode)) {
                 const content = child.content;
                 let processedContent = content.replace(/\s+/g, ' ').trim();
                 if (processedContent) {
@@ -3515,29 +4707,26 @@ class Printer extends Visitor {
                     if (hasTrailingSpace && !currentLineContent.endsWith(' ')) {
                         currentLineContent += ' ';
                     }
-                    if ((indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-                        this.visitTextFlowChildrenMultiline(children);
+                    if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
+                        children.forEach(child => this.visit(child));
                         return;
                     }
                 }
             }
-            else if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const element = child;
-                const openTag = element.open_tag;
-                const childTagName = openTag?.tag_name?.value || '';
+            else if (isNode(child, HTMLElementNode)) {
+                const childTagName = getTagName(child);
                 if (this.isInlineElement(childTagName)) {
-                    const childInline = this.tryRenderInlineFull(element, childTagName, this.extractAttributes(openTag.children), element.body.filter(c => !(c instanceof WhitespaceNode || c.type === 'AST_WHITESPACE_NODE') &&
-                        !((c instanceof HTMLTextNode || c.type === 'AST_HTML_TEXT_NODE') && c?.content.trim() === "")));
+                    const childInline = this.tryRenderInlineFull(child, childTagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), this.filterEmptyNodes(child.body));
                     if (childInline) {
                         currentLineContent += childInline;
-                        if ((indent.length + currentLineContent.length) > this.maxLineLength) {
-                            this.visitTextFlowChildrenMultiline(children);
+                        if ((this.indent.length + currentLineContent.length) > this.maxLineLength) {
+                            children.forEach(child => this.visit(child));
                             return;
                         }
                     }
                     else {
                         if (currentLineContent.trim()) {
-                            this.push(indent + currentLineContent.trim());
+                            this.push(this.indent + currentLineContent.trim());
                             currentLineContent = "";
                         }
                         this.visit(child);
@@ -3545,23 +4734,26 @@ class Printer extends Visitor {
                 }
                 else {
                     if (currentLineContent.trim()) {
-                        this.push(indent + currentLineContent.trim());
+                        this.push(this.indent + currentLineContent.trim());
                         currentLineContent = "";
                     }
                     this.visit(child);
                 }
             }
-            else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
+            else if (isNode(child, ERBContentNode)) {
                 const oldLines = this.lines;
                 const oldInlineMode = this.inlineMode;
+                // TODO: use this.capture
                 try {
                     this.lines = [];
                     this.inlineMode = true;
                     this.visit(child);
                     const erbContent = this.lines.join("");
                     currentLineContent += erbContent;
-                    if ((indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-                        this.visitTextFlowChildrenMultiline(children);
+                    if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
+                        this.lines = oldLines;
+                        this.inlineMode = oldInlineMode;
+                        children.forEach(child => this.visit(child));
                         return;
                     }
                 }
@@ -3572,53 +4764,38 @@ class Printer extends Visitor {
             }
             else {
                 if (currentLineContent.trim()) {
-                    this.push(indent + currentLineContent.trim());
+                    this.push(this.indent + currentLineContent.trim());
                     currentLineContent = "";
                 }
                 this.visit(child);
             }
         }
         if (currentLineContent.trim()) {
-            const finalLine = indent + currentLineContent.trim();
+            const finalLine = this.indent + currentLineContent.trim();
             if (finalLine.length > Math.max(this.maxLineLength, 120)) {
-                this.visitTextFlowChildrenMultiline(children);
+                this.visitAll(children);
                 return;
             }
             this.push(finalLine);
         }
     }
-    visitTextFlowChildrenMultiline(children) {
-        children.forEach(child => this.visit(child));
-    }
-    isInTextFlowContext(parent, children) {
-        const hasTextContent = children.some(child => (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') &&
-            child.content.trim() !== "");
-        if (!hasTextContent) {
+    isInTextFlowContext(_parent, children) {
+        const hasTextContent = children.some(child => isNode(child, HTMLTextNode) && child.content.trim() !== "");
+        const nonTextChildren = children.filter(child => !isNode(child, HTMLTextNode));
+        if (!hasTextContent)
             return false;
-        }
-        const nonTextChildren = children.filter(child => !(child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE'));
-        if (nonTextChildren.length === 0) {
+        if (nonTextChildren.length === 0)
             return false;
-        }
         const allInline = nonTextChildren.every(child => {
-            if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
+            if (isNode(child, ERBContentNode))
                 return true;
-            }
-            if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const element = child;
-                const openTag = element.open_tag;
-                const tagName = openTag?.tag_name?.value || '';
-                return this.isInlineElement(tagName);
+            if (isNode(child, HTMLElementNode)) {
+                return this.isInlineElement(getTagName(child));
             }
             return false;
         });
-        if (!allInline) {
+        if (!allInline)
             return false;
-        }
-        const maxNestingDepth = this.getMaxNestingDepth(children, 0);
-        if (maxNestingDepth > 2) {
-            return false;
-        }
         return true;
     }
     renderInlineOpen(name, attributes, selfClose, inlineNodes = [], allChildren = []) {
@@ -3626,73 +4803,68 @@ class Printer extends Visitor {
         if (inlineNodes.length > 0) {
             let result = `<${name}`;
             if (allChildren.length > 0) {
-                const currentIndentLevel = this.indentLevel;
-                this.indentLevel = 0;
-                const tempLines = this.lines;
-                this.lines = [];
-                allChildren.forEach(child => {
-                    if (child instanceof HTMLAttributeNode || child.type === 'AST_HTML_ATTRIBUTE_NODE') {
-                        this.lines.push(" " + this.renderAttribute(child));
-                    }
-                    else if (!(child instanceof WhitespaceNode || child.type === 'AST_WHITESPACE_NODE')) {
-                        const wasInlineMode = this.inlineMode;
-                        this.inlineMode = true;
-                        this.lines.push(" ");
-                        this.visit(child);
-                        this.inlineMode = wasInlineMode;
-                    }
+                const lines = this.capture(() => {
+                    allChildren.forEach(child => {
+                        if (isNode(child, HTMLAttributeNode)) {
+                            this.lines.push(" " + this.renderAttribute(child));
+                        }
+                        else if (!(isNode(child, WhitespaceNode))) {
+                            const wasInlineMode = this.inlineMode;
+                            this.inlineMode = true;
+                            this.lines.push(" ");
+                            this.visit(child);
+                            this.inlineMode = wasInlineMode;
+                        }
+                    });
                 });
-                const inlineContent = this.lines.join("");
-                this.lines = tempLines;
-                this.indentLevel = currentIndentLevel;
-                result += inlineContent;
+                result += lines.join("");
             }
             else {
                 if (parts.length > 0) {
                     result += ` ${parts.join(" ")}`;
                 }
-                const currentIndentLevel = this.indentLevel;
-                this.indentLevel = 0;
-                const tempLines = this.lines;
-                this.lines = [];
-                inlineNodes.forEach(node => {
-                    const wasInlineMode = this.inlineMode;
-                    if (!this.isERBControlFlow(node)) {
-                        this.inlineMode = true;
-                    }
-                    this.visit(node);
-                    this.inlineMode = wasInlineMode;
+                const lines = this.capture(() => {
+                    inlineNodes.forEach(node => {
+                        const wasInlineMode = this.inlineMode;
+                        if (!isERBControlFlowNode(node)) {
+                            this.inlineMode = true;
+                        }
+                        this.visit(node);
+                        this.inlineMode = wasInlineMode;
+                    });
                 });
-                const inlineContent = this.lines.join("");
-                this.lines = tempLines;
-                this.indentLevel = currentIndentLevel;
-                result += inlineContent;
+                result += lines.join("");
             }
             result += selfClose ? " />" : ">";
             return result;
         }
-        return `<${name}${parts.length ? " " + parts.join(" ") : ""}${selfClose ? " /" : ""}>`;
+        return `<${name}${parts.length ? " " + parts.join(" ") : ""}${selfClose ? " />" : ">"}`;
     }
     renderAttribute(attribute) {
-        const name = attribute.name.name.value ?? "";
+        const name = attribute.name ? getCombinedAttributeName(attribute.name) : "";
         const equals = attribute.equals?.value ?? "";
+        this.currentAttributeName = name;
         let value = "";
-        if (attribute.value && (attribute.value instanceof HTMLAttributeValueNode || attribute.value?.type === 'AST_HTML_ATTRIBUTE_VALUE_NODE')) {
+        if (attribute.value && isNode(attribute.value, HTMLAttributeValueNode)) {
             const attributeValue = attribute.value;
             let open_quote = attributeValue.open_quote?.value ?? "";
             let close_quote = attributeValue.close_quote?.value ?? "";
             let htmlTextContent = "";
             const content = attributeValue.children.map((child) => {
-                if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE' || child instanceof LiteralNode || child.type === 'AST_LITERAL_NODE') {
-                    const textContent = child.content;
-                    htmlTextContent += textContent;
-                    return textContent;
+                if (isNode(child, HTMLTextNode) || isNode(child, LiteralNode)) {
+                    htmlTextContent += child.content;
+                    return child.content;
+                }
+                else if (isNode(child, ERBContentNode)) {
+                    return IdentityPrinter.print(child);
                 }
-                else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
-                    const erbAttribute = child;
-                    return erbAttribute.tag_opening.value + erbAttribute.content.value + erbAttribute.tag_closing.value;
+                else {
+                    const printed = IdentityPrinter.print(child);
+                    if (this.currentAttributeName && FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)) {
+                        return printed.replace(/%>([^<\s])/g, '%> $1').replace(/([^>\s])<%/g, '$1 <%');
+                    }
+                    return printed;
                 }
-                return "";
             }).join("");
             if (open_quote === "" && close_quote === "") {
                 open_quote = '"';
@@ -3702,21 +4874,31 @@ class Printer extends Visitor {
                 open_quote = '"';
                 close_quote = '"';
             }
-            value = open_quote + content + close_quote;
+            if (this.isFormattableAttribute(name, this.currentTagName)) {
+                if (name === 'class') {
+                    value = this.formatClassAttribute(content, name, equals, open_quote, close_quote);
+                }
+                else {
+                    value = this.formatMultilineAttribute(content, name, open_quote, close_quote);
+                }
+            }
+            else {
+                value = open_quote + content + close_quote;
+            }
         }
+        this.currentAttributeName = null;
         return name + equals + value;
     }
     /**
      * Try to render a complete element inline including opening tag, children, and closing tag
      */
-    tryRenderInlineFull(node, tagName, attributes, children) {
+    tryRenderInlineFull(_node, tagName, attributes, children) {
         let result = `<${tagName}`;
         result += this.renderAttributesString(attributes);
         result += ">";
         const childrenContent = this.tryRenderChildrenInline(children);
-        if (!childrenContent) {
+        if (!childrenContent)
             return null;
-        }
         result += childrenContent;
         result += `</${tagName}>`;
         return result;
@@ -3727,11 +4909,10 @@ class Printer extends Visitor {
     tryRenderChildrenInline(children) {
         let result = "";
         for (const child of children) {
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                const content = child.content;
-                const normalizedContent = content.replace(/\s+/g, ' ');
-                const hasLeadingSpace = /^\s/.test(content);
-                const hasTrailingSpace = /\s$/.test(content);
+            if (isNode(child, HTMLTextNode)) {
+                const normalizedContent = child.content.replace(/\s+/g, ' ');
+                const hasLeadingSpace = /^\s/.test(child.content);
+                const hasTrailingSpace = /\s$/.test(child.content);
                 const trimmedContent = normalizedContent.trim();
                 if (trimmedContent) {
                     let finalContent = trimmedContent;
@@ -3749,36 +4930,19 @@ class Printer extends Visitor {
                     }
                 }
             }
-            else if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const element = child;
-                const openTag = element.open_tag;
-                const childTagName = openTag?.tag_name?.value || '';
-                if (!this.isInlineElement(childTagName)) {
+            else if (isNode(child, HTMLElementNode)) {
+                const tagName = getTagName(child);
+                if (!this.isInlineElement(tagName)) {
                     return null;
                 }
-                const childInline = this.tryRenderInlineFull(element, childTagName, this.extractAttributes(openTag.children), element.body.filter(c => !(c instanceof WhitespaceNode || c.type === 'AST_WHITESPACE_NODE') &&
-                    !((c instanceof HTMLTextNode || c.type === 'AST_HTML_TEXT_NODE') && c?.content.trim() === "")));
+                const childInline = this.tryRenderInlineFull(child, tagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), this.filterEmptyNodes(child.body));
                 if (!childInline) {
                     return null;
                 }
                 result += childInline;
             }
             else {
-                const oldLines = this.lines;
-                const oldInlineMode = this.inlineMode;
-                const oldIndentLevel = this.indentLevel;
-                try {
-                    this.lines = [];
-                    this.inlineMode = true;
-                    this.indentLevel = 0;
-                    this.visit(child);
-                    result += this.lines.join("");
-                }
-                finally {
-                    this.lines = oldLines;
-                    this.inlineMode = oldInlineMode;
-                    this.indentLevel = oldIndentLevel;
-                }
+                result += this.capture(() => this.visit(child)).join("");
             }
         }
         return result.trim();
@@ -3787,142 +4951,145 @@ class Printer extends Visitor {
      * Try to render children inline if they are simple enough.
      * Returns the inline string if possible, null otherwise.
      */
-    tryRenderInline(children, tagName, depth = 0, forceInline = false, hasTextFlow = false) {
-        if (!forceInline && children.length > 10) {
-            return null;
-        }
-        const maxNestingDepth = this.getMaxNestingDepth(children, 0);
-        let maxAllowedDepth = forceInline ? 5 : (tagName && ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'div'].includes(tagName) ? 1 : 2);
-        if (hasTextFlow && maxNestingDepth >= 2) {
-            const roughContentLength = this.estimateContentLength(children);
-            if (roughContentLength > 47) {
-                maxAllowedDepth = 1;
-            }
-        }
-        if (!forceInline && maxNestingDepth > maxAllowedDepth) {
-            this.isInComplexNesting = true;
-            return null;
-        }
+    tryRenderInline(children, tagName) {
         for (const child of children) {
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                const textContent = child.content;
-                if (textContent.includes('\n')) {
+            if (isNode(child, HTMLTextNode)) {
+                if (child.content.includes('\n')) {
                     return null;
                 }
             }
-            else if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const element = child;
-                const openTag = element.open_tag;
-                const elementTagName = openTag?.tag_name?.value || '';
-                const isInlineElement = this.isInlineElement(elementTagName);
+            else if (isNode(child, HTMLElementNode)) {
+                const isInlineElement = this.isInlineElement(getTagName(child));
                 if (!isInlineElement) {
                     return null;
                 }
             }
-            else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') ;
+            else if (isNode(child, ERBContentNode)) ;
             else {
                 return null;
             }
         }
-        const oldLines = this.lines;
-        const oldInlineMode = this.inlineMode;
-        try {
-            this.lines = [];
-            this.inlineMode = true;
-            let content = '';
-            for (const child of children) {
-                if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                    content += child.content;
-                }
-                else if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                    const element = child;
-                    const openTag = element.open_tag;
-                    const childTagName = openTag?.tag_name?.value || '';
-                    const attributes = this.extractAttributes(openTag.children);
-                    const attributesString = this.renderAttributesString(attributes);
-                    const elementContent = this.renderElementInline(element);
-                    content += `<${childTagName}${attributesString}>${elementContent}</${childTagName}>`;
+        let content = "";
+        this.capture(() => {
+            content = this.renderChildrenInline(children);
+        });
+        return `<${tagName}>${content}</${tagName}>`;
+    }
+    /**
+     * Check if children contain mixed text and inline elements (like "text<em>inline</em>text")
+     * or mixed ERB output and text (like "<%= value %> text")
+     * This indicates content that should be formatted inline even with structural newlines
+     */
+    hasMixedTextAndInlineContent(children) {
+        let hasText = false;
+        let hasInlineElements = false;
+        for (const child of children) {
+            if (isNode(child, HTMLTextNode)) {
+                if (child.content.trim() !== "") {
+                    hasText = true;
                 }
-                else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
-                    const erbNode = child;
-                    const open = erbNode.tag_opening?.value ?? "";
-                    const erbContent = erbNode.content?.value ?? "";
-                    const close = erbNode.tag_closing?.value ?? "";
-                    content += `${open}${this.formatERBContent(erbContent)}${close}`;
+            }
+            else if (isNode(child, HTMLElementNode)) {
+                if (this.isInlineElement(getTagName(child))) {
+                    hasInlineElements = true;
                 }
             }
-            content = content.replace(/\s+/g, ' ').trim();
-            return `<${tagName}>${content}</${tagName}>`;
-        }
-        finally {
-            this.lines = oldLines;
-            this.inlineMode = oldInlineMode;
         }
+        return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText);
     }
     /**
-     * Estimate the total content length of children nodes for decision making.
+     * Check if children contain any text content with newlines
      */
-    estimateContentLength(children) {
-        let length = 0;
+    hasMultilineTextContent(children) {
         for (const child of children) {
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
-                length += child.content.length;
-            }
-            else if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const element = child;
-                const openTag = element.open_tag;
-                const tagName = openTag?.tag_name?.value || '';
-                length += tagName.length + 5; // Rough estimate for tag overhead
-                length += this.estimateContentLength(element.body);
+            if (isNode(child, HTMLTextNode)) {
+                return child.content.includes('\n');
             }
-            else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
-                length += child.content?.value.length || 0;
+            if (isNode(child, HTMLElementNode)) {
+                const nestedChildren = this.filterEmptyNodes(child.body);
+                if (this.hasMultilineTextContent(nestedChildren)) {
+                    return true;
+                }
             }
         }
-        return length;
+        return false;
     }
     /**
-     * Calculate the maximum nesting depth in a subtree of nodes.
+     * Check if all nested elements in the children are inline elements
      */
-    getMaxNestingDepth(children, currentDepth) {
-        let maxDepth = currentDepth;
+    areAllNestedElementsInline(children) {
         for (const child of children) {
-            if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const element = child;
-                const elementChildren = element.body.filter(child => !(child instanceof WhitespaceNode || child.type === 'AST_WHITESPACE_NODE') &&
-                    !((child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') && child?.content.trim() === ""));
-                const childDepth = this.getMaxNestingDepth(elementChildren, currentDepth + 1);
-                maxDepth = Math.max(maxDepth, childDepth);
+            if (isNode(child, HTMLElementNode)) {
+                if (!this.isInlineElement(getTagName(child))) {
+                    return false;
+                }
+                const nestedChildren = this.filterEmptyNodes(child.body);
+                if (!this.areAllNestedElementsInline(nestedChildren)) {
+                    return false;
+                }
+            }
+            else if (isAnyOf(child, HTMLDoctypeNode, HTMLCommentNode, isERBControlFlowNode)) {
+                return false;
             }
         }
-        return maxDepth;
+        return true;
+    }
+    /**
+     * Check if element has complex ERB control flow
+     */
+    hasComplexERBControlFlow(inlineNodes) {
+        return inlineNodes.some(node => {
+            if (isNode(node, ERBIfNode)) {
+                if (node.statements.length > 0 && node.location) {
+                    const startLine = node.location.start.line;
+                    const endLine = node.location.end.line;
+                    return startLine !== endLine;
+                }
+                return false;
+            }
+            return false;
+        });
+    }
+    /**
+     * Filter children to remove insignificant whitespace
+     */
+    filterSignificantChildren(body, hasTextFlow) {
+        return body.filter(child => {
+            if (isNode(child, WhitespaceNode))
+                return false;
+            if (isNode(child, HTMLTextNode)) {
+                if (hasTextFlow && child.content === " ")
+                    return true;
+                return child.content.trim() !== "";
+            }
+            return true;
+        });
     }
     /**
-     * Render an HTML element's content inline (without the wrapping tags).
+     * Filter out empty text nodes and whitespace nodes
      */
+    filterEmptyNodes(nodes) {
+        return nodes.filter(child => !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === ""));
+    }
     renderElementInline(element) {
-        const children = element.body.filter(child => !(child instanceof WhitespaceNode || child.type === 'AST_WHITESPACE_NODE') &&
-            !((child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') && child?.content.trim() === ""));
+        const children = this.filterEmptyNodes(element.body);
+        return this.renderChildrenInline(children);
+    }
+    renderChildrenInline(children) {
         let content = '';
         for (const child of children) {
-            if (child instanceof HTMLTextNode || child.type === 'AST_HTML_TEXT_NODE') {
+            if (isNode(child, HTMLTextNode)) {
                 content += child.content;
             }
-            else if (child instanceof HTMLElementNode || child.type === 'AST_HTML_ELEMENT_NODE') {
-                const childElement = child;
-                const openTag = childElement.open_tag;
-                const childTagName = openTag?.tag_name?.value || '';
-                const attributes = this.extractAttributes(openTag.children);
+            else if (isNode(child, HTMLElementNode)) {
+                const tagName = getTagName(child);
+                const attributes = filterNodes(child.open_tag?.children, HTMLAttributeNode);
                 const attributesString = this.renderAttributesString(attributes);
-                const childContent = this.renderElementInline(childElement);
-                content += `<${childTagName}${attributesString}>${childContent}</${childTagName}>`;
+                const childContent = this.renderElementInline(child);
+                content += `<${tagName}${attributesString}>${childContent}</${tagName}>`;
             }
-            else if (child instanceof ERBContentNode || child.type === 'AST_ERB_CONTENT_NODE') {
-                const erbNode = child;
-                const open = erbNode.tag_opening?.value ?? "";
-                const erbContent = erbNode.content?.value ?? "";
-                const close = erbNode.tag_closing?.value ?? "";
-                content += `${open}${this.formatERBContent(erbContent)}${close}`;
+            else if (isNode(child, ERBContentNode)) {
+                content += this.reconstructERBNode(child, true);
             }
         }
         return content.replace(/\s+/g, ' ').trim();
@@ -3967,7 +5134,7 @@ class Formatter {
         if (result.failed)
             return source;
         const resolvedOptions = resolveFormatOptions({ ...this.options, ...options });
-        return new Printer(source, resolvedOptions).print(result.value);
+        return new FormatPrinter(source, resolvedOptions).print(result.value);
     }
     parse(source) {
         this.herb.ensureBackend();
@@ -3975,5 +5142,5 @@ class Formatter {
     }
 }
 
-export { Formatter, defaultFormatOptions, resolveFormatOptions };
+export { FormatPrinter, Formatter, defaultFormatOptions, resolveFormatOptions };
 //# sourceMappingURL=index.esm.js.map