@herb-tools/formatter 0.7.4 → 0.8.0

package/dist/index.esm.js

@@ -10,6 +10,7 @@ function createDedent(options) {
   function dedent(strings, ...values) {
     const raw = typeof strings === "string" ? [strings] : strings.raw;
     const {
+      alignValues = false,
       escapeSpecialCharacters = Array.isArray(strings),
       trimWhitespace = true
     } = options;
@@ -24,8 +25,10 @@ function createDedent(options) {
       }
       result += next;
       if (i < values.length) {
+        const value = alignValues ? alignValue(values[i], result) : values[i];
+
         // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-        result += values[i];
+        result += value;
       }
     }
 
@@ -65,11 +68,35 @@ function createDedent(options) {
   }
 }
 
+/**
+ * Adjusts the indentation of a multi-line interpolated value to match the current line.
+ */
+function alignValue(value, precedingText) {
+  if (typeof value !== "string" || !value.includes("\n")) {
+    return value;
+  }
+  const currentLine = precedingText.slice(precedingText.lastIndexOf("\n") + 1);
+  const indentMatch = currentLine.match(/^(\s+)/);
+  if (indentMatch) {
+    const indent = indentMatch[1];
+    return value.replace(/\n/g, `\n${indent}`);
+  }
+  return value;
+}
+
 class Position {
     line;
     column;
-    static from(position) {
-        return new Position(position.line, position.column);
+    static from(positionOrLine, column) {
+        if (typeof positionOrLine === "number") {
+            return new Position(positionOrLine, column);
+        }
+        else {
+            return new Position(positionOrLine.line, positionOrLine.column);
+        }
+    }
+    static get zero() {
+        return new Position(0, 0);
     }
     constructor(line, column) {
         this.line = line;
@@ -95,10 +122,20 @@ class Position {
 class Location {
     start;
     end;
-    static from(location) {
-        const start = Position.from(location.start);
-        const end = Position.from(location.end);
-        return new Location(start, end);
+    static from(locationOrLine, column, endLine, endColumn) {
+        if (typeof locationOrLine === "number") {
+            const start = Position.from(locationOrLine, column);
+            const end = Position.from(endLine, endColumn);
+            return new Location(start, end);
+        }
+        else {
+            const start = Position.from(locationOrLine.start);
+            const end = Position.from(locationOrLine.end);
+            return new Location(start, end);
+        }
+    }
+    static get zero() {
+        return new Location(Position.zero, Position.zero);
     }
     constructor(start, end) {
         this.start = start;
@@ -130,8 +167,16 @@ class Location {
 class Range {
     start;
     end;
-    static from(range) {
-        return new Range(range[0], range[1]);
+    static from(rangeOrStart, end) {
+        if (typeof rangeOrStart === "number") {
+            return new Range(rangeOrStart, end);
+        }
+        else {
+            return new Range(rangeOrStart[0], rangeOrStart[1]);
+        }
+    }
+    static get zero() {
+        return new Range(0, 0);
     }
     constructor(start, end) {
         this.start = start;
@@ -196,7 +241,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-0.7.4/templates/javascript/packages/core/src/errors.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/errors.ts.erb
 class HerbError {
     type;
     message;
@@ -621,6 +666,84 @@ class RubyParseError extends HerbError {
         return output;
     }
 }
+class ERBControlFlowScopeError extends HerbError {
+    keyword;
+    static from(data) {
+        return new ERBControlFlowScopeError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            keyword: data.keyword,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.keyword = props.keyword;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "ERB_CONTROL_FLOW_SCOPE_ERROR",
+            keyword: this.keyword,
+        };
+    }
+    toMonacoDiagnostic() {
+        return {
+            line: this.location.start.line,
+            column: this.location.start.column,
+            endLine: this.location.end.line,
+            endColumn: this.location.end.column,
+            message: this.message,
+            severity: 'error'
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ ERBControlFlowScopeError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `└── keyword: ${JSON.stringify(this.keyword)}\n`;
+        return output;
+    }
+}
+class MissingERBEndTagError extends HerbError {
+    keyword;
+    static from(data) {
+        return new MissingERBEndTagError({
+            type: data.type,
+            message: data.message,
+            location: Location.from(data.location),
+            keyword: data.keyword,
+        });
+    }
+    constructor(props) {
+        super(props.type, props.message, props.location);
+        this.keyword = props.keyword;
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            type: "MISSINGERB_END_TAG_ERROR",
+            keyword: this.keyword,
+        };
+    }
+    toMonacoDiagnostic() {
+        return {
+            line: this.location.start.line,
+            column: this.location.start.column,
+            endLine: this.location.end.line,
+            endColumn: this.location.end.column,
+            message: this.message,
+            severity: 'error'
+        };
+    }
+    treeInspect() {
+        let output = "";
+        output += `@ MissingERBEndTagError ${this.location.treeInspectWithLabel()}\n`;
+        output += `├── message: "${this.message}"\n`;
+        output += `└── keyword: ${JSON.stringify(this.keyword)}\n`;
+        return output;
+    }
+}
 function fromSerializedError(error) {
     switch (error.type) {
         case "UNEXPECTED_ERROR": return UnexpectedError.from(error);
@@ -632,6 +755,8 @@ function fromSerializedError(error) {
         case "VOID_ELEMENT_CLOSING_TAG_ERROR": return VoidElementClosingTagError.from(error);
         case "UNCLOSED_ELEMENT_ERROR": return UnclosedElementError.from(error);
         case "RUBY_PARSE_ERROR": return RubyParseError.from(error);
+        case "ERB_CONTROL_FLOW_SCOPE_ERROR": return ERBControlFlowScopeError.from(error);
+        case "MISSINGERB_END_TAG_ERROR": return MissingERBEndTagError.from(error);
         default:
             throw new Error(`Unknown node type: ${error.type}`);
     }
@@ -646,7 +771,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-0.7.4/templates/javascript/packages/core/src/nodes.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/nodes.ts.erb
 class Node {
     type;
     location;
@@ -2880,7 +3005,7 @@ class ParseResult extends Result {
 }
 
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/javascript/packages/core/src/node-type-guards.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.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
@@ -3265,7 +3390,7 @@ function isParseResult(object) {
  * Checks if a node is an ERB output node (generates content: <%= %> or <%== %>)
  */
 function isERBOutputNode(node) {
-    if (!isNode(node, ERBContentNode))
+    if (!isERBNode(node))
         return false;
     if (!node.tag_opening?.value)
         return false;
@@ -3367,7 +3492,7 @@ function getNodesAfterPosition(nodes, position, inclusive = true) {
 }
 
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/javascript/packages/core/src/visitor.ts.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/javascript/packages/core/src/visitor.ts.erb
 class Visitor {
     visit(node) {
         if (!node)
@@ -3380,97 +3505,151 @@ class Visitor {
     visitChildNodes(node) {
         node.compactChildNodes().forEach(node => node.accept(this));
     }
+    visitNode(_node) {
+        // Default implementation does nothing
+    }
+    visitERBNode(_node) {
+        // Default implementation does nothing
+    }
     visitDocumentNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitLiteralNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLOpenTagNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLCloseTagNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLElementNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLAttributeValueNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLAttributeNameNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLAttributeNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLTextNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLCommentNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitHTMLDoctypeNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitXMLDeclarationNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitCDATANode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitWhitespaceNode(node) {
+        this.visitNode(node);
         this.visitChildNodes(node);
     }
     visitERBContentNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBEndNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBElseNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBIfNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBBlockNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBWhenNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBCaseNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBCaseMatchNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBWhileNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBUntilNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBForNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBRescueNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBEnsureNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBBeginNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBUnlessNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBYieldNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
     visitERBInNode(node) {
+        this.visitNode(node);
+        this.visitERBNode(node);
         this.visitChildNodes(node);
     }
 }
@@ -3629,6 +3808,11 @@ class Printer extends Visitor {
  * - Verifying AST round-trip fidelity
  */
 class IdentityPrinter extends Printer {
+    static printERBNode(node) {
+        const printer = new IdentityPrinter();
+        printer.printERBNode(node);
+        return printer.context.getOutput();
+    }
     visitLiteralNode(node) {
         this.write(node.content);
     }
@@ -3916,11 +4100,396 @@ class IdentityPrinter extends Printer {
 ({
     ...DEFAULT_PRINT_OPTIONS});
 
+// --- Constants ---
 // TODO: we can probably expand this list with more tags/attributes
 const FORMATTABLE_ATTRIBUTES = {
     '*': ['class'],
     'img': ['srcset', 'sizes']
 };
+const INLINE_ELEMENTS = new Set([
+    'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'br', 'cite', 'code',
+    'dfn', 'em', 'hr', 'i', 'img', 'kbd', 'label', 'map', 'object', 'q',
+    'samp', 'small', 'span', 'strong', 'sub', 'sup',
+    'tt', 'var', 'del', 'ins', 'mark', 's', 'u', 'time', 'wbr'
+]);
+const CONTENT_PRESERVING_ELEMENTS = new Set([
+    'script', 'style', 'pre', 'textarea'
+]);
+const SPACEABLE_CONTAINERS = new Set([
+    'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
+    'figure', 'details', 'summary', 'dialog', 'fieldset'
+]);
+const TIGHT_GROUP_PARENTS = new Set([
+    'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead',
+    'tbody', 'tfoot'
+]);
+const TIGHT_GROUP_CHILDREN = new Set([
+    'li', 'option', 'td', 'th', 'dt', 'dd'
+]);
+const SPACING_THRESHOLD = 3;
+/**
+ * Token list attributes that contain space-separated values and benefit from
+ * spacing around ERB content for readability
+ */
+const TOKEN_LIST_ATTRIBUTES = new Set([
+    'class', 'data-controller', 'data-action'
+]);
+// --- Node Utility Functions ---
+/**
+ * Check if a node is pure whitespace (empty text node with only whitespace)
+ */
+function isPureWhitespaceNode(node) {
+    return isNode(node, HTMLTextNode) && node.content.trim() === "";
+}
+/**
+ * Check if a node is non-whitespace (has meaningful content)
+ */
+function isNonWhitespaceNode(node) {
+    if (isNode(node, WhitespaceNode))
+        return false;
+    if (isNode(node, HTMLTextNode))
+        return node.content.trim() !== "";
+    return true;
+}
+/**
+ * Find the previous meaningful (non-whitespace) sibling
+ * Returns -1 if no meaningful sibling is found
+ */
+function findPreviousMeaningfulSibling(siblings, currentIndex) {
+    for (let i = currentIndex - 1; i >= 0; i--) {
+        if (isNonWhitespaceNode(siblings[i])) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Check if there's whitespace between two indices in children array
+ */
+function hasWhitespaceBetween(children, startIndex, endIndex) {
+    for (let j = startIndex + 1; j < endIndex; j++) {
+        if (isNode(children[j], WhitespaceNode) || isPureWhitespaceNode(children[j])) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Filter children to remove insignificant whitespace
+ */
+function filterSignificantChildren(body) {
+    return body.filter(child => {
+        if (isNode(child, WhitespaceNode))
+            return false;
+        if (isNode(child, HTMLTextNode)) {
+            if (child.content === " ")
+                return true;
+            return child.content.trim() !== "";
+        }
+        return true;
+    });
+}
+/**
+ * Smart filter that preserves exactly ONE whitespace before herb:disable comments
+ */
+function filterEmptyNodesForHerbDisable(nodes) {
+    const result = [];
+    let pendingWhitespace = null;
+    for (const node of nodes) {
+        const isWhitespace = isNode(node, WhitespaceNode) || (isNode(node, HTMLTextNode) && node.content.trim() === "");
+        const isHerbDisable = isNode(node, ERBContentNode) && isHerbDisableComment(node);
+        if (isWhitespace) {
+            if (!pendingWhitespace) {
+                pendingWhitespace = node;
+            }
+        }
+        else {
+            if (isHerbDisable && pendingWhitespace) {
+                result.push(pendingWhitespace);
+            }
+            pendingWhitespace = null;
+            result.push(node);
+        }
+    }
+    return result;
+}
+// --- Punctuation and Word Spacing Functions ---
+/**
+ * Check if a word is standalone closing punctuation
+ */
+function isClosingPunctuation(word) {
+    return /^[.,;:!?)\]]+$/.test(word);
+}
+/**
+ * Check if a line ends with opening punctuation
+ */
+function lineEndsWithOpeningPunctuation(line) {
+    return /[(\[]$/.test(line);
+}
+/**
+ * Check if a string ends with an ERB tag
+ */
+function endsWithERBTag(text) {
+    return /%>$/.test(text.trim());
+}
+/**
+ * Check if a string starts with an ERB tag
+ */
+function startsWithERBTag(text) {
+    return /^<%/.test(text.trim());
+}
+/**
+ * Determine if space is needed between the current line and the next word
+ */
+function needsSpaceBetween(currentLine, word) {
+    if (isClosingPunctuation(word))
+        return false;
+    if (lineEndsWithOpeningPunctuation(currentLine))
+        return false;
+    if (currentLine.endsWith(' '))
+        return false;
+    if (word.startsWith(' '))
+        return false;
+    if (endsWithERBTag(currentLine) && startsWithERBTag(word))
+        return false;
+    return true;
+}
+/**
+ * Build a line by adding a word with appropriate spacing
+ */
+function buildLineWithWord(currentLine, word) {
+    if (!currentLine)
+        return word;
+    if (word === ' ') {
+        return currentLine.endsWith(' ') ? currentLine : `${currentLine} `;
+    }
+    if (isClosingPunctuation(word)) {
+        currentLine = currentLine.trimEnd();
+        return `${currentLine}${word}`;
+    }
+    return needsSpaceBetween(currentLine, word) ? `${currentLine} ${word}` : `${currentLine}${word}`;
+}
+/**
+ * Check if a node is an inline element or ERB node
+ */
+function isInlineOrERBNode(node) {
+    return isERBNode(node) || (isNode(node, HTMLElementNode) && isInlineElement(getTagName(node)));
+}
+/**
+ * Check if an element should be treated as inline based on its tag name
+ */
+function isInlineElement(tagName) {
+    return INLINE_ELEMENTS.has(tagName.toLowerCase());
+}
+/**
+ * Check if the current inline element is adjacent to a previous inline element (no whitespace between)
+ */
+function isAdjacentToPreviousInline(siblings, index) {
+    const previousNode = siblings[index - 1];
+    if (isInlineOrERBNode(previousNode)) {
+        return true;
+    }
+    if (index > 1 && isNode(previousNode, HTMLTextNode) && !/^\s/.test(previousNode.content)) {
+        const twoBack = siblings[index - 2];
+        return isInlineOrERBNode(twoBack);
+    }
+    return false;
+}
+/**
+ * Check if a node should be appended to the last line (for adjacent inline elements and punctuation)
+ */
+function shouldAppendToLastLine(child, siblings, index) {
+    if (index === 0)
+        return false;
+    if (isNode(child, HTMLTextNode) && !/^\s/.test(child.content)) {
+        const previousNode = siblings[index - 1];
+        return isInlineOrERBNode(previousNode);
+    }
+    if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
+        return isAdjacentToPreviousInline(siblings, index);
+    }
+    if (isNode(child, ERBContentNode)) {
+        for (let i = index - 1; i >= 0; i--) {
+            const previousSibling = siblings[i];
+            if (isPureWhitespaceNode(previousSibling) || isNode(previousSibling, WhitespaceNode)) {
+                continue;
+            }
+            if (previousSibling.location && child.location) {
+                return previousSibling.location.end.line === child.location.start.line;
+            }
+            break;
+        }
+    }
+    return false;
+}
+/**
+ * Check if user-intentional spacing should be preserved (double newlines between elements)
+ */
+function shouldPreserveUserSpacing(child, siblings, index) {
+    if (!isPureWhitespaceNode(child))
+        return false;
+    const hasPreviousNonWhitespace = index > 0 && isNonWhitespaceNode(siblings[index - 1]);
+    const hasNextNonWhitespace = index < siblings.length - 1 && isNonWhitespaceNode(siblings[index + 1]);
+    const hasMultipleNewlines = isNode(child, HTMLTextNode) && child.content.includes('\n\n');
+    return hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines;
+}
+/**
+ * Check if children contain any text content with newlines
+ */
+function hasMultilineTextContent(children) {
+    for (const child of children) {
+        if (isNode(child, HTMLTextNode)) {
+            return child.content.includes('\n');
+        }
+        if (isNode(child, HTMLElementNode) && hasMultilineTextContent(child.body)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if all nested elements in the children are inline elements
+ */
+function areAllNestedElementsInline(children) {
+    for (const child of children) {
+        if (isNode(child, HTMLElementNode)) {
+            if (!isInlineElement(getTagName(child))) {
+                return false;
+            }
+            if (!areAllNestedElementsInline(child.body)) {
+                return false;
+            }
+        }
+        else if (isAnyOf(child, HTMLDoctypeNode, HTMLCommentNode, isERBControlFlowNode)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Check if element has complex ERB control flow
+ */
+function 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;
+    });
+}
+/**
+ * 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
+ */
+function 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 (isNode(child, HTMLElementNode)) {
+            if (isInlineElement(getTagName(child))) {
+                hasInlineElements = true;
+            }
+        }
+    }
+    return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText);
+}
+function isContentPreserving(element) {
+    const tagName = getTagName(element);
+    return CONTENT_PRESERVING_ELEMENTS.has(tagName);
+}
+/**
+ * Count consecutive inline elements/ERB at the start of children (with no whitespace between)
+ */
+function countAdjacentInlineElements(children) {
+    let count = 0;
+    let lastSignificantIndex = -1;
+    for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+            continue;
+        }
+        const isInlineOrERB = (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) || isNode(child, ERBContentNode);
+        if (!isInlineOrERB) {
+            break;
+        }
+        if (lastSignificantIndex >= 0 && hasWhitespaceBetween(children, lastSignificantIndex, i)) {
+            break;
+        }
+        count++;
+        lastSignificantIndex = i;
+    }
+    return count;
+}
+/**
+ * Check if a node represents a block-level element
+ */
+function isBlockLevelNode(node) {
+    if (!isNode(node, HTMLElementNode)) {
+        return false;
+    }
+    const tagName = getTagName(node);
+    if (INLINE_ELEMENTS.has(tagName)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Check if an element is a line-breaking element (br or hr)
+ */
+function isLineBreakingElement(node) {
+    if (!isNode(node, HTMLElementNode)) {
+        return false;
+    }
+    const tagName = getTagName(node);
+    return tagName === 'br' || tagName === 'hr';
+}
+/**
+ * Normalize text by replacing multiple spaces with single space and trim
+ * Then split into words
+ */
+function normalizeAndSplitWords(text) {
+    const normalized = text.replace(/\s+/g, ' ');
+    return normalized.trim().split(' ');
+}
+/**
+ * Check if text ends with whitespace
+ */
+function endsWithWhitespace(text) {
+    return /\s$/.test(text);
+}
+/**
+ * Check if an ERB content node is a herb:disable comment
+ */
+function isHerbDisableComment(node) {
+    if (!isNode(node, ERBContentNode))
+        return false;
+    if (node.tag_opening?.value !== "<%#")
+        return false;
+    const content = node?.content?.value || "";
+    const trimmed = content.trim();
+    return trimmed.startsWith("herb:disable");
+}
+/**
+ * Check if a text node is YAML frontmatter (starts and ends with ---)
+ */
+function isFrontmatter(node) {
+    if (!isNode(node, HTMLTextNode))
+        return false;
+    const content = node.content.trim();
+    return content.startsWith("---") && /---\s*$/.test(content);
+}
+
 /**
  * Printer traverses the Herb AST using the Visitor pattern
  * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
@@ -3944,28 +4513,6 @@ class FormatPrinter extends Printer {
     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 CONTENT_PRESERVING_ELEMENTS = new Set([
-        'script', 'style', 'pre', 'textarea'
-    ]);
-    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;
@@ -4124,20 +4671,20 @@ class FormatPrinter extends Printer {
         if (hasMixedContent) {
             return false;
         }
-        const meaningfulSiblings = siblings.filter(child => this.isNonWhitespaceNode(child));
-        if (meaningfulSiblings.length < FormatPrinter.SPACING_THRESHOLD) {
+        const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child));
+        if (meaningfulSiblings.length < SPACING_THRESHOLD) {
             return false;
         }
         const parentTagName = parentElement ? getTagName(parentElement) : null;
-        if (parentTagName && FormatPrinter.TIGHT_GROUP_PARENTS.has(parentTagName)) {
+        if (parentTagName && TIGHT_GROUP_PARENTS.has(parentTagName)) {
             return false;
         }
-        const isSpaceableContainer = !parentTagName || (parentTagName && FormatPrinter.SPACEABLE_CONTAINERS.has(parentTagName));
+        const isSpaceableContainer = !parentTagName || (parentTagName && SPACEABLE_CONTAINERS.has(parentTagName));
         if (!isSpaceableContainer && meaningfulSiblings.length < 5) {
             return false;
         }
         const currentNode = siblings[currentIndex];
-        const previousMeaningfulIndex = this.findPreviousMeaningfulSibling(siblings, currentIndex);
+        const previousMeaningfulIndex = findPreviousMeaningfulSibling(siblings, currentIndex);
         const isCurrentComment = isCommentNode(currentNode);
         if (previousMeaningfulIndex !== -1) {
             const previousNode = siblings[previousMeaningfulIndex];
@@ -4151,66 +4698,34 @@ class FormatPrinter extends Printer {
         }
         if (isNode(currentNode, HTMLElementNode)) {
             const currentTagName = getTagName(currentNode);
-            if (FormatPrinter.INLINE_ELEMENTS.has(currentTagName)) {
+            if (INLINE_ELEMENTS.has(currentTagName)) {
                 return false;
             }
-            if (FormatPrinter.TIGHT_GROUP_CHILDREN.has(currentTagName)) {
+            if (TIGHT_GROUP_CHILDREN.has(currentTagName)) {
                 return false;
             }
             if (currentTagName === 'a' && parentTagName === 'nav') {
                 return false;
             }
         }
-        const isBlockElement = this.isBlockLevelNode(currentNode);
+        const isBlockElement = isBlockLevelNode(currentNode);
         const isERBBlock = isERBNode(currentNode) && isERBControlFlowNode(currentNode);
         const isComment = isCommentNode(currentNode);
         return isBlockElement || isERBBlock || isComment;
     }
-    /**
-     * Token list attributes that contain space-separated values and benefit from
-     * spacing around ERB content for readability
-     */
-    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);
+    get isInTokenListAttribute() {
+        return this.currentAttributeName !== null && TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName);
     }
     /**
-     * Find the previous meaningful (non-whitespace) sibling
+     * Render attributes as a space-separated string
      */
-    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
-     */
-    renderAttributesString(attributes) {
-        if (attributes.length === 0)
-            return "";
-        return ` ${attributes.map(attribute => this.renderAttribute(attribute)).join(" ")}`;
+    renderAttributesString(attributes) {
+        if (attributes.length === 0)
+            return "";
+        return ` ${attributes.map(attribute => this.renderAttribute(attribute)).join(" ")}`;
     }
     /**
      * Determine if a tag should be rendered inline based on attribute count and other factors
@@ -4240,9 +4755,6 @@ class FormatPrinter extends Printer {
         }
         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);
@@ -4264,6 +4776,11 @@ class FormatPrinter extends Printer {
         }
         return false;
     }
+    // TOOD: extract to core or reuse function from core
+    getAttributeName(attribute) {
+        return attribute.name ? getCombinedAttributeName(attribute.name) : "";
+    }
+    // TOOD: extract to core or reuse function from core
     getAttributeValue(attribute) {
         if (isNode(attribute.value, HTMLAttributeValueNode)) {
             return attribute.value.children.map(child => isNode(child, HTMLTextNode) ? child.content : IdentityPrinter.print(child)).join('');
@@ -4399,28 +4916,38 @@ class FormatPrinter extends Printer {
     }
     // --- Visitor methods ---
     visitDocumentNode(node) {
+        const children = this.formatFrontmatter(node);
+        const hasTextFlow = this.isInTextFlowContext(null, children);
+        if (hasTextFlow) {
+            const wasInlineMode = this.inlineMode;
+            this.inlineMode = true;
+            this.visitTextFlowChildren(children);
+            this.inlineMode = wasInlineMode;
+            return;
+        }
         let lastWasMeaningful = false;
         let hasHandledSpacing = false;
-        for (let i = 0; i < node.children.length; i++) {
-            const child = node.children[i];
-            if (isNode(child, HTMLTextNode)) {
-                const isWhitespaceOnly = child.content.trim() === "";
-                if (isWhitespaceOnly) {
-                    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 = child.content.includes('\n\n');
-                    if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
-                        this.push("");
-                        hasHandledSpacing = true;
-                    }
-                    continue;
-                }
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (shouldPreserveUserSpacing(child, children, i)) {
+                this.push("");
+                hasHandledSpacing = true;
+                continue;
+            }
+            if (isPureWhitespaceNode(child)) {
+                continue;
             }
-            if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+            if (shouldAppendToLastLine(child, children, i)) {
+                this.appendChildToLastLine(child, children, i);
+                lastWasMeaningful = true;
+                hasHandledSpacing = false;
+                continue;
+            }
+            if (isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
                 this.push("");
             }
             this.visit(child);
-            if (this.isNonWhitespaceNode(child)) {
+            if (isNonWhitespaceNode(child)) {
                 lastWasMeaningful = true;
                 hasHandledSpacing = false;
             }
@@ -4429,6 +4956,12 @@ class FormatPrinter extends Printer {
     visitHTMLElementNode(node) {
         this.elementStack.push(node);
         this.elementFormattingAnalysis.set(node, this.analyzeElementFormatting(node));
+        if (this.inlineMode && node.is_void && this.indentLevel === 0) {
+            const openTag = this.capture(() => this.visit(node.open_tag)).join('');
+            this.pushToLastLine(openTag);
+            this.elementStack.pop();
+            return;
+        }
         this.visit(node.open_tag);
         if (node.body.length > 0) {
             this.visitHTMLElementBody(node.body, node);
@@ -4439,7 +4972,8 @@ class FormatPrinter extends Printer {
         this.elementStack.pop();
     }
     visitHTMLElementBody(body, element) {
-        if (this.isContentPreserving(element)) {
+        const tagName = getTagName(element);
+        if (isContentPreserving(element)) {
             element.body.map(child => {
                 if (isNode(child, HTMLElementNode)) {
                     const wasInlineMode = this.inlineMode;
@@ -4456,12 +4990,14 @@ class FormatPrinter extends Printer {
         }
         const analysis = this.elementFormattingAnalysis.get(element);
         const hasTextFlow = this.isInTextFlowContext(null, body);
-        const children = this.filterSignificantChildren(body, hasTextFlow);
+        const children = filterSignificantChildren(body);
         if (analysis?.elementContentInline) {
             if (children.length === 0)
                 return;
             const oldInlineMode = this.inlineMode;
             const nodesToRender = hasTextFlow ? body : children;
+            const hasOnlyTextContent = nodesToRender.every(child => isNode(child, HTMLTextNode) || isNode(child, WhitespaceNode));
+            const shouldPreserveSpaces = hasOnlyTextContent && isInlineElement(tagName);
             this.inlineMode = true;
             const lines = this.capture(() => {
                 nodesToRender.forEach(child => {
@@ -4476,10 +5012,19 @@ class FormatPrinter extends Printer {
                             }
                         }
                         else {
-                            const normalizedContent = child.content.replace(/\s+/g, ' ').trim();
-                            if (normalizedContent) {
+                            const normalizedContent = child.content.replace(/\s+/g, ' ');
+                            if (shouldPreserveSpaces && normalizedContent) {
                                 this.push(normalizedContent);
                             }
+                            else {
+                                const trimmedContent = normalizedContent.trim();
+                                if (trimmedContent) {
+                                    this.push(trimmedContent);
+                                }
+                                else if (normalizedContent === ' ') {
+                                    this.push(' ');
+                                }
+                            }
                         }
                     }
                     else if (isNode(child, WhitespaceNode)) {
@@ -4491,7 +5036,9 @@ class FormatPrinter extends Printer {
                 });
             });
             const content = lines.join('');
-            const inlineContent = hasTextFlow ? content.replace(/\s+/g, ' ').trim() : content.trim();
+            const inlineContent = shouldPreserveSpaces
+                ? (hasTextFlow ? content.replace(/\s+/g, ' ') : content)
+                : (hasTextFlow ? content.replace(/\s+/g, ' ').trim() : content.trim());
             if (inlineContent) {
                 this.pushToLastLine(inlineContent);
             }
@@ -4500,12 +5047,69 @@ class FormatPrinter extends Printer {
         }
         if (children.length === 0)
             return;
+        let leadingHerbDisableComment = null;
+        let leadingHerbDisableIndex = -1;
+        let firstWhitespaceIndex = -1;
+        let remainingChildren = children;
+        let remainingBodyUnfiltered = body;
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (isNode(child, WhitespaceNode) || isPureWhitespaceNode(child)) {
+                if (firstWhitespaceIndex < 0) {
+                    firstWhitespaceIndex = i;
+                }
+                continue;
+            }
+            if (isNode(child, ERBContentNode) && isHerbDisableComment(child)) {
+                leadingHerbDisableComment = child;
+                leadingHerbDisableIndex = i;
+            }
+            break;
+        }
+        if (leadingHerbDisableComment && leadingHerbDisableIndex >= 0) {
+            remainingChildren = children.filter((_, index) => {
+                if (index === leadingHerbDisableIndex)
+                    return false;
+                if (firstWhitespaceIndex >= 0 && index === leadingHerbDisableIndex - 1) {
+                    const child = children[index];
+                    if (isNode(child, WhitespaceNode) || isPureWhitespaceNode(child)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+            remainingBodyUnfiltered = body.filter((_, index) => {
+                if (index === leadingHerbDisableIndex)
+                    return false;
+                if (firstWhitespaceIndex >= 0 && index === leadingHerbDisableIndex - 1) {
+                    const child = body[index];
+                    if (isNode(child, WhitespaceNode) || isPureWhitespaceNode(child)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        }
+        if (leadingHerbDisableComment) {
+            const herbDisableString = this.capture(() => {
+                const savedIndentLevel = this.indentLevel;
+                this.indentLevel = 0;
+                this.inlineMode = true;
+                this.visit(leadingHerbDisableComment);
+                this.inlineMode = false;
+                this.indentLevel = savedIndentLevel;
+            }).join("");
+            const hasLeadingWhitespace = firstWhitespaceIndex >= 0 && firstWhitespaceIndex < leadingHerbDisableIndex;
+            this.pushToLastLine((hasLeadingWhitespace ? ' ' : '') + herbDisableString);
+        }
+        if (remainingChildren.length === 0)
+            return;
         this.withIndent(() => {
             if (hasTextFlow) {
-                this.visitTextFlowChildren(children);
+                this.visitTextFlowChildren(remainingBodyUnfiltered);
             }
             else {
-                this.visitElementChildren(body, element);
+                this.visitElementChildren(leadingHerbDisableComment ? remainingChildren : body, element);
             }
         });
     }
@@ -4520,8 +5124,8 @@ class FormatPrinter extends Printer {
             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 hasPreviousNonWhitespace = i > 0 && isNonWhitespaceNode(body[i - 1]);
+                    const hasNextNonWhitespace = i < body.length - 1 && isNonWhitespaceNode(body[i + 1]);
                     const hasMultipleNewlines = child.content.includes('\n\n');
                     if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
                         this.push("");
@@ -4530,7 +5134,7 @@ class FormatPrinter extends Printer {
                     continue;
                 }
             }
-            if (this.isNonWhitespaceNode(child) && lastWasMeaningful && !hasHandledSpacing) {
+            if (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);
@@ -4538,8 +5142,35 @@ class FormatPrinter extends Printer {
                     this.push("");
                 }
             }
-            this.visit(child);
-            if (this.isNonWhitespaceNode(child)) {
+            let hasTrailingHerbDisable = false;
+            if (isNode(child, HTMLElementNode) && child.close_tag) {
+                for (let j = i + 1; j < body.length; j++) {
+                    const nextChild = body[j];
+                    if (isNode(nextChild, WhitespaceNode) || isPureWhitespaceNode(nextChild)) {
+                        continue;
+                    }
+                    if (isNode(nextChild, ERBContentNode) && isHerbDisableComment(nextChild)) {
+                        hasTrailingHerbDisable = true;
+                        this.visit(child);
+                        const herbDisableString = this.capture(() => {
+                            const savedIndentLevel = this.indentLevel;
+                            this.indentLevel = 0;
+                            this.inlineMode = true;
+                            this.visit(nextChild);
+                            this.inlineMode = false;
+                            this.indentLevel = savedIndentLevel;
+                        }).join("");
+                        this.pushToLastLine(' ' + herbDisableString);
+                        i = j;
+                        break;
+                    }
+                    break;
+                }
+            }
+            if (!hasTrailingHerbDisable) {
+                this.visit(child);
+            }
+            if (isNonWhitespaceNode(child)) {
                 lastWasMeaningful = true;
                 hasHandledSpacing = false;
             }
@@ -4629,8 +5260,8 @@ class FormatPrinter extends Printer {
                 if (isNode(child, HTMLTextNode) || isNode(child, LiteralNode)) {
                     return child.content;
                 }
-                else if (isERBNode(child) || isNode(child, ERBContentNode)) {
-                    return this.reconstructERBNode(child, false);
+                else if (isERBNode(child)) {
+                    return IdentityPrinter.print(child);
                 }
                 else {
                     return "";
@@ -4683,11 +5314,21 @@ class FormatPrinter extends Printer {
         if (contentLines.length === 1 && contentTrimmedLines.length === 1) {
             const startsWithSpace = content[0] === " ";
             const before = startsWithSpace ? "" : " ";
-            this.pushWithIndent(open + before + content.trimEnd() + ' ' + close);
+            if (this.inlineMode) {
+                this.push(open + before + content.trimEnd() + ' ' + close);
+            }
+            else {
+                this.pushWithIndent(open + before + content.trimEnd() + ' ' + close);
+            }
             return;
         }
         if (contentTrimmedLines.length === 1) {
-            this.pushWithIndent(open + ' ' + content.trim() + ' ' + close);
+            if (this.inlineMode) {
+                this.push(open + ' ' + content.trim() + ' ' + close);
+            }
+            else {
+                this.pushWithIndent(open + ' ' + content.trim() + ' ' + close);
+            }
             return;
         }
         const firstLineEmpty = contentLines[0].trim() === "";
@@ -4728,6 +5369,7 @@ class FormatPrinter extends Printer {
     }
     visitERBCaseMatchNode(node) {
         this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.children));
         this.visitAll(node.conditions);
         if (node.else_clause)
             this.visit(node.else_clause);
@@ -4736,7 +5378,15 @@ class FormatPrinter extends Printer {
     }
     visitERBBlockNode(node) {
         this.printERBNode(node);
-        this.withIndent(() => this.visitElementChildren(node.body, null));
+        this.withIndent(() => {
+            const hasTextFlow = this.isInTextFlowContext(null, node.body);
+            if (hasTextFlow) {
+                this.visitTextFlowChildren(node.body);
+            }
+            else {
+                this.visitElementChildren(node.body, null);
+            }
+        });
         if (node.end_node)
             this.visit(node.end_node);
     }
@@ -4749,7 +5399,7 @@ class FormatPrinter extends Printer {
                     this.lines.push(this.renderAttribute(child));
                 }
                 else {
-                    const shouldAddSpaces = this.isInTokenListAttribute();
+                    const shouldAddSpaces = this.isInTokenListAttribute;
                     if (shouldAddSpaces) {
                         this.lines.push(" ");
                     }
@@ -4760,12 +5410,12 @@ class FormatPrinter extends Printer {
                 }
             });
             const hasHTMLAttributes = node.statements.some(child => isNode(child, HTMLAttributeNode));
-            const isTokenList = this.isInTokenListAttribute();
+            const isTokenList = this.isInTokenListAttribute;
             if ((hasHTMLAttributes || isTokenList) && node.end_node) {
                 this.lines.push(" ");
             }
             if (node.subsequent)
-                this.visit(node.end_node);
+                this.visit(node.subsequent);
             if (node.end_node)
                 this.visit(node.end_node);
         }
@@ -4781,8 +5431,14 @@ class FormatPrinter extends Printer {
         }
     }
     visitERBElseNode(node) {
-        this.printERBNode(node);
-        this.withIndent(() => node.statements.forEach(statement => this.visit(statement)));
+        if (this.inlineMode) {
+            this.printERBNode(node);
+            node.statements.forEach(statement => this.visit(statement));
+        }
+        else {
+            this.printERBNode(node);
+            this.withIndent(() => node.statements.forEach(statement => this.visit(statement)));
+        }
     }
     visitERBWhenNode(node) {
         this.printERBNode(node);
@@ -4790,6 +5446,7 @@ class FormatPrinter extends Printer {
     }
     visitERBCaseNode(node) {
         this.printERBNode(node);
+        this.withIndent(() => this.visitAll(node.children));
         this.visitAll(node.conditions);
         if (node.else_clause)
             this.visit(node.else_clause);
@@ -4864,7 +5521,7 @@ class FormatPrinter extends Printer {
         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);
+        const hasComplexERB = hasERBControlFlow && hasComplexERBControlFlow(inlineNodes);
         if (hasComplexERB)
             return false;
         const totalAttributeCount = this.getTotalAttributeCount(attributes, inlineNodes);
@@ -4879,26 +5536,38 @@ class FormatPrinter extends Printer {
      */
     shouldRenderElementContentInline(node) {
         const tagName = getTagName(node);
-        const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body));
-        const isInlineElement = this.isInlineElement(tagName);
+        const children = filterSignificantChildren(node.body);
         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);
+        let hasLeadingHerbDisable = false;
+        for (const child of node.body) {
+            if (isNode(child, WhitespaceNode) || isPureWhitespaceNode(child)) {
+                continue;
+            }
+            if (isNode(child, ERBContentNode) && isHerbDisableComment(child)) {
+                hasLeadingHerbDisable = true;
+            }
+            break;
+        }
+        if (hasLeadingHerbDisable && !isInlineElement(tagName)) {
+            return false;
+        }
+        if (isInlineElement(tagName)) {
+            const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body);
             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);
+        const allNestedAreInline = areAllNestedElementsInline(children);
+        const hasMultilineText = hasMultilineTextContent(children);
+        const hasMixedContent = hasMixedTextAndInlineContent(children);
         if (allNestedAreInline && (!hasMultilineText || hasMixedContent)) {
-            const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), children);
+            const fullInlineResult = this.tryRenderInlineFull(node, tagName, filterNodes(node.open_tag?.children, HTMLAttributeNode), node.body);
             if (fullInlineResult) {
                 const totalLength = this.indent.length + fullInlineResult.length;
                 if (totalLength <= this.maxLineLength) {
@@ -4925,117 +5594,551 @@ class FormatPrinter extends Printer {
             return true;
         if (node.open_tag?.tag_closing?.value === "/>")
             return true;
-        if (this.isContentPreserving(node))
+        if (isContentPreserving(node))
             return true;
-        const children = this.filterSignificantChildren(node.body, this.isInTextFlowContext(null, node.body));
+        const children = filterSignificantChildren(node.body);
         if (children.length === 0)
             return true;
         return elementContentInline;
     }
     // --- Utility methods ---
-    isNonWhitespaceNode(node) {
-        if (isNode(node, WhitespaceNode))
-            return false;
-        if (isNode(node, HTMLTextNode))
-            return node.content.trim() !== "";
-        return true;
+    formatFrontmatter(node) {
+        const firstChild = node.children[0];
+        const hasFrontmatter = firstChild && isFrontmatter(firstChild);
+        if (!hasFrontmatter)
+            return node.children;
+        this.push(firstChild.content.trimEnd());
+        const remaining = node.children.slice(1);
+        if (remaining.length > 0)
+            this.push("");
+        return remaining;
     }
     /**
-     * Check if an element should be treated as inline based on its tag name
+     * Append a child node to the last output line
      */
-    isInlineElement(tagName) {
-        return FormatPrinter.INLINE_ELEMENTS.has(tagName.toLowerCase());
+    appendChildToLastLine(child, siblings, index) {
+        if (isNode(child, HTMLTextNode)) {
+            this.pushToLastLine(child.content.trim());
+        }
+        else {
+            let hasSpaceBefore = false;
+            if (siblings && index !== undefined && index > 0) {
+                const prevSibling = siblings[index - 1];
+                if (isPureWhitespaceNode(prevSibling) || isNode(prevSibling, WhitespaceNode)) {
+                    hasSpaceBefore = true;
+                }
+            }
+            const oldInlineMode = this.inlineMode;
+            this.inlineMode = true;
+            const inlineContent = this.capture(() => this.visit(child)).join("");
+            this.inlineMode = oldInlineMode;
+            this.pushToLastLine((hasSpaceBefore ? " " : "") + inlineContent);
+        }
     }
     /**
-     * Check if we're in a text flow context (parent contains mixed text and inline elements)
+     * Visit children in a text flow context (mixed text and inline elements)
+     * Handles word wrapping and keeps adjacent inline elements together
      */
     visitTextFlowChildren(children) {
-        let currentLineContent = "";
-        for (const child of children) {
-            if (isNode(child, HTMLTextNode)) {
-                const content = child.content;
-                let processedContent = content.replace(/\s+/g, ' ').trim();
-                if (processedContent) {
-                    const hasLeadingSpace = /^\s/.test(content);
-                    if (currentLineContent && hasLeadingSpace && !currentLineContent.endsWith(' ')) {
-                        currentLineContent += ' ';
-                    }
-                    currentLineContent += processedContent;
-                    const hasTrailingSpace = /\s$/.test(content);
-                    if (hasTrailingSpace && !currentLineContent.endsWith(' ')) {
-                        currentLineContent += ' ';
-                    }
-                    if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-                        children.forEach(child => this.visit(child));
-                        return;
+        const adjacentInlineCount = countAdjacentInlineElements(children);
+        if (adjacentInlineCount >= 2) {
+            const { processedIndices } = this.renderAdjacentInlineElements(children, adjacentInlineCount);
+            this.visitRemainingChildren(children, processedIndices);
+            return;
+        }
+        this.buildAndWrapTextFlow(children);
+    }
+    /**
+     * Wrap remaining words that don't fit on the current line
+     * Returns the wrapped lines with proper indentation
+     */
+    wrapRemainingWords(words, wrapWidth) {
+        const lines = [];
+        let line = "";
+        for (const word of words) {
+            const testLine = line + (line ? " " : "") + word;
+            if (testLine.length > wrapWidth && line) {
+                lines.push(this.indent + line);
+                line = word;
+            }
+            else {
+                line = testLine;
+            }
+        }
+        if (line) {
+            lines.push(this.indent + line);
+        }
+        return lines;
+    }
+    /**
+     * Try to merge text starting with punctuation to inline content
+     * Returns object with merged content and whether processing should stop
+     */
+    tryMergePunctuationText(inlineContent, trimmedText, wrapWidth) {
+        const combined = inlineContent + trimmedText;
+        if (combined.length <= wrapWidth) {
+            return {
+                mergedContent: inlineContent + trimmedText,
+                shouldStop: false,
+                wrappedLines: []
+            };
+        }
+        const match = trimmedText.match(/^[.!?:;]+/);
+        if (!match) {
+            return {
+                mergedContent: inlineContent,
+                shouldStop: false,
+                wrappedLines: []
+            };
+        }
+        const punctuation = match[0];
+        const restText = trimmedText.substring(punctuation.length).trim();
+        if (!restText) {
+            return {
+                mergedContent: inlineContent + punctuation,
+                shouldStop: false,
+                wrappedLines: []
+            };
+        }
+        const words = restText.split(/\s+/);
+        let toMerge = punctuation;
+        let mergedWordCount = 0;
+        for (const word of words) {
+            const testMerge = toMerge + ' ' + word;
+            if ((inlineContent + testMerge).length <= wrapWidth) {
+                toMerge = testMerge;
+                mergedWordCount++;
+            }
+            else {
+                break;
+            }
+        }
+        const mergedContent = inlineContent + toMerge;
+        if (mergedWordCount >= words.length) {
+            return {
+                mergedContent,
+                shouldStop: false,
+                wrappedLines: []
+            };
+        }
+        const remainingWords = words.slice(mergedWordCount);
+        const wrappedLines = this.wrapRemainingWords(remainingWords, wrapWidth);
+        return {
+            mergedContent,
+            shouldStop: true,
+            wrappedLines
+        };
+    }
+    /**
+     * Render adjacent inline elements together on one line
+     */
+    renderAdjacentInlineElements(children, count) {
+        let inlineContent = "";
+        let processedCount = 0;
+        let lastProcessedIndex = -1;
+        const processedIndices = new Set();
+        for (let index = 0; index < children.length && processedCount < count; index++) {
+            const child = children[index];
+            if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+                continue;
+            }
+            if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
+                inlineContent += this.renderInlineElementAsString(child);
+                processedCount++;
+                lastProcessedIndex = index;
+                processedIndices.add(index);
+                if (inlineContent && isLineBreakingElement(child)) {
+                    this.pushWithIndent(inlineContent);
+                    inlineContent = "";
+                }
+            }
+            else if (isNode(child, ERBContentNode)) {
+                inlineContent += this.renderERBAsString(child);
+                processedCount++;
+                lastProcessedIndex = index;
+                processedIndices.add(index);
+            }
+        }
+        if (lastProcessedIndex >= 0) {
+            for (let index = lastProcessedIndex + 1; index < children.length; index++) {
+                const child = children[index];
+                if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+                    continue;
+                }
+                if (isNode(child, ERBContentNode)) {
+                    inlineContent += this.renderERBAsString(child);
+                    processedIndices.add(index);
+                    continue;
+                }
+                if (isNode(child, HTMLTextNode)) {
+                    const trimmed = child.content.trim();
+                    if (trimmed && /^[.!?:;]/.test(trimmed)) {
+                        const wrapWidth = this.maxLineLength - this.indent.length;
+                        const result = this.tryMergePunctuationText(inlineContent, trimmed, wrapWidth);
+                        inlineContent = result.mergedContent;
+                        processedIndices.add(index);
+                        if (result.shouldStop) {
+                            if (inlineContent) {
+                                this.pushWithIndent(inlineContent);
+                            }
+                            result.wrappedLines.forEach(line => this.push(line));
+                            return { processedIndices };
+                        }
                     }
                 }
+                break;
             }
-            else if (isNode(child, HTMLElementNode)) {
-                const childTagName = getTagName(child);
-                if (this.isInlineElement(childTagName)) {
-                    const childInline = this.tryRenderInlineFull(child, childTagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), this.filterEmptyNodes(child.body));
-                    if (childInline) {
-                        currentLineContent += childInline;
-                        if ((this.indent.length + currentLineContent.length) > this.maxLineLength) {
-                            children.forEach(child => this.visit(child));
-                            return;
+        }
+        if (inlineContent) {
+            this.pushWithIndent(inlineContent);
+        }
+        return { processedIndices };
+    }
+    /**
+     * Render an inline element as a string
+     */
+    renderInlineElementAsString(element) {
+        const tagName = getTagName(element);
+        if (element.is_void || element.open_tag?.tag_closing?.value === "/>") {
+            const attributes = filterNodes(element.open_tag?.children, HTMLAttributeNode);
+            const attributesString = this.renderAttributesString(attributes);
+            const isSelfClosing = element.open_tag?.tag_closing?.value === "/>";
+            return `<${tagName}${attributesString}${isSelfClosing ? " />" : ">"}`;
+        }
+        const childrenToRender = this.getFilteredChildren(element.body);
+        const childInline = this.tryRenderInlineFull(element, tagName, filterNodes(element.open_tag?.children, HTMLAttributeNode), childrenToRender);
+        return childInline !== null ? childInline : "";
+    }
+    /**
+     * Render an ERB node as a string
+     */
+    renderERBAsString(node) {
+        return this.capture(() => {
+            this.inlineMode = true;
+            this.visit(node);
+        }).join("");
+    }
+    /**
+     * Visit remaining children after processing adjacent inline elements
+     */
+    visitRemainingChildren(children, processedIndices) {
+        for (let index = 0; index < children.length; index++) {
+            const child = children[index];
+            if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+                continue;
+            }
+            if (processedIndices.has(index)) {
+                continue;
+            }
+            this.visit(child);
+        }
+    }
+    /**
+     * Build words array from text/inline/ERB and wrap them
+     */
+    buildAndWrapTextFlow(children) {
+        const unitsWithNodes = this.buildContentUnitsWithNodes(children);
+        const words = [];
+        for (const { unit, node } of unitsWithNodes) {
+            if (unit.breaksFlow) {
+                this.flushWords(words);
+                if (node) {
+                    this.visit(node);
+                }
+            }
+            else if (unit.isAtomic) {
+                words.push({ word: unit.content, isHerbDisable: unit.isHerbDisable || false });
+            }
+            else {
+                const text = unit.content.replace(/\s+/g, ' ');
+                const hasLeadingSpace = text.startsWith(' ');
+                const hasTrailingSpace = text.endsWith(' ');
+                const trimmedText = text.trim();
+                if (trimmedText) {
+                    if (hasLeadingSpace && words.length > 0) {
+                        const lastWord = words[words.length - 1];
+                        if (!lastWord.word.endsWith(' ')) {
+                            lastWord.word += ' ';
                         }
                     }
-                    else {
-                        if (currentLineContent.trim()) {
-                            this.pushWithIndent(currentLineContent.trim());
-                            currentLineContent = "";
+                    const textWords = trimmedText.split(' ').map(w => ({ word: w, isHerbDisable: false }));
+                    words.push(...textWords);
+                    if (hasTrailingSpace && words.length > 0) {
+                        const lastWord = words[words.length - 1];
+                        if (!isClosingPunctuation(lastWord.word)) {
+                            lastWord.word += ' ';
                         }
-                        this.visit(child);
                     }
                 }
-                else {
-                    if (currentLineContent.trim()) {
-                        this.pushWithIndent(currentLineContent.trim());
-                        currentLineContent = "";
+                else if (text === ' ' && words.length > 0) {
+                    const lastWord = words[words.length - 1];
+                    if (!lastWord.word.endsWith(' ')) {
+                        lastWord.word += ' ';
                     }
-                    this.visit(child);
                 }
             }
-            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 ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-                        this.lines = oldLines;
-                        this.inlineMode = oldInlineMode;
-                        children.forEach(child => this.visit(child));
-                        return;
+        }
+        this.flushWords(words);
+    }
+    /**
+     * Try to merge text that follows an atomic unit (ERB/inline) with no whitespace
+     * Returns true if merge was performed
+     */
+    tryMergeTextAfterAtomic(result, textNode) {
+        if (result.length === 0)
+            return false;
+        const lastUnit = result[result.length - 1];
+        if (!lastUnit.unit.isAtomic || (lastUnit.unit.type !== 'erb' && lastUnit.unit.type !== 'inline')) {
+            return false;
+        }
+        const words = normalizeAndSplitWords(textNode.content);
+        if (words.length === 0 || !words[0])
+            return false;
+        const firstWord = words[0];
+        const firstChar = firstWord[0];
+        if (!/[a-zA-Z0-9.!?:;]/.test(firstChar)) {
+            return false;
+        }
+        lastUnit.unit.content += firstWord;
+        if (words.length > 1) {
+            let remainingText = words.slice(1).join(' ');
+            if (endsWithWhitespace(textNode.content)) {
+                remainingText += ' ';
+            }
+            result.push({
+                unit: { content: remainingText, type: 'text', isAtomic: false, breaksFlow: false },
+                node: textNode
+            });
+        }
+        return true;
+    }
+    /**
+     * Try to merge an atomic unit (ERB/inline) with preceding text that has no whitespace
+     * Returns true if merge was performed
+     */
+    tryMergeAtomicAfterText(result, children, lastProcessedIndex, atomicContent, atomicType, atomicNode) {
+        if (result.length === 0)
+            return false;
+        const lastUnit = result[result.length - 1];
+        if (lastUnit.unit.type !== 'text' || lastUnit.unit.isAtomic)
+            return false;
+        const words = normalizeAndSplitWords(lastUnit.unit.content);
+        const lastWord = words[words.length - 1];
+        if (!lastWord)
+            return false;
+        result.pop();
+        if (words.length > 1) {
+            const remainingText = words.slice(0, -1).join(' ');
+            result.push({
+                unit: { content: remainingText, type: 'text', isAtomic: false, breaksFlow: false },
+                node: children[lastProcessedIndex]
+            });
+        }
+        result.push({
+            unit: { content: lastWord + atomicContent, type: atomicType, isAtomic: true, breaksFlow: false },
+            node: atomicNode
+        });
+        return true;
+    }
+    /**
+     * Check if there's whitespace between current node and last processed node
+     */
+    hasWhitespaceBeforeNode(children, lastProcessedIndex, currentIndex, currentNode) {
+        if (hasWhitespaceBetween(children, lastProcessedIndex, currentIndex)) {
+            return true;
+        }
+        if (isNode(currentNode, HTMLTextNode) && /^\s/.test(currentNode.content)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if last unit in result ends with whitespace
+     */
+    lastUnitEndsWithWhitespace(result) {
+        if (result.length === 0)
+            return false;
+        const lastUnit = result[result.length - 1];
+        return lastUnit.unit.type === 'text' && endsWithWhitespace(lastUnit.unit.content);
+    }
+    /**
+     * Process a text node and add it to results (with potential merging)
+     */
+    processTextNode(result, children, child, index, lastProcessedIndex) {
+        const isAtomic = child.content === ' ';
+        if (!isAtomic && lastProcessedIndex >= 0 && result.length > 0) {
+            const hasWhitespace = this.hasWhitespaceBeforeNode(children, lastProcessedIndex, index, child);
+            const lastUnit = result[result.length - 1];
+            const lastIsAtomic = lastUnit.unit.isAtomic && (lastUnit.unit.type === 'erb' || lastUnit.unit.type === 'inline');
+            const trimmed = child.content.trim();
+            const startsWithClosingPunct = trimmed.length > 0 && /^[.!?:;]/.test(trimmed);
+            if (lastIsAtomic && (!hasWhitespace || startsWithClosingPunct) && this.tryMergeTextAfterAtomic(result, child)) {
+                return;
+            }
+        }
+        result.push({
+            unit: { content: child.content, type: 'text', isAtomic, breaksFlow: false },
+            node: child
+        });
+    }
+    /**
+     * Process an inline element and add it to results (with potential merging)
+     */
+    processInlineElement(result, children, child, index, lastProcessedIndex) {
+        const tagName = getTagName(child);
+        const childrenToRender = this.getFilteredChildren(child.body);
+        const inlineContent = this.tryRenderInlineFull(child, tagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), childrenToRender);
+        if (inlineContent === null) {
+            result.push({
+                unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+                node: child
+            });
+            return false;
+        }
+        if (lastProcessedIndex >= 0) {
+            const hasWhitespace = hasWhitespaceBetween(children, lastProcessedIndex, index) || this.lastUnitEndsWithWhitespace(result);
+            if (!hasWhitespace && this.tryMergeAtomicAfterText(result, children, lastProcessedIndex, inlineContent, 'inline', child)) {
+                return true;
+            }
+        }
+        result.push({
+            unit: { content: inlineContent, type: 'inline', isAtomic: true, breaksFlow: false },
+            node: child
+        });
+        return false;
+    }
+    /**
+     * Process an ERB content node and add it to results (with potential merging)
+     */
+    processERBContentNode(result, children, child, index, lastProcessedIndex) {
+        const erbContent = this.renderERBAsString(child);
+        const isHerbDisable = isHerbDisableComment(child);
+        if (lastProcessedIndex >= 0) {
+            const hasWhitespace = hasWhitespaceBetween(children, lastProcessedIndex, index) || this.lastUnitEndsWithWhitespace(result);
+            if (!hasWhitespace && this.tryMergeAtomicAfterText(result, children, lastProcessedIndex, erbContent, 'erb', child)) {
+                return true;
+            }
+            if (hasWhitespace && result.length > 0) {
+                const lastUnit = result[result.length - 1];
+                const lastIsAtomic = lastUnit.unit.isAtomic && (lastUnit.unit.type === 'inline' || lastUnit.unit.type === 'erb');
+                if (lastIsAtomic && !this.lastUnitEndsWithWhitespace(result)) {
+                    result.push({
+                        unit: { content: ' ', type: 'text', isAtomic: true, breaksFlow: false },
+                        node: null
+                    });
+                }
+            }
+        }
+        result.push({
+            unit: { content: erbContent, type: 'erb', isAtomic: true, breaksFlow: false, isHerbDisable },
+            node: child
+        });
+        return false;
+    }
+    /**
+     * Convert AST nodes to content units with node references
+     */
+    buildContentUnitsWithNodes(children) {
+        const result = [];
+        let lastProcessedIndex = -1;
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (isNode(child, WhitespaceNode))
+                continue;
+            if (isPureWhitespaceNode(child) && !(isNode(child, HTMLTextNode) && child.content === ' ')) {
+                if (lastProcessedIndex >= 0) {
+                    const hasNonWhitespaceAfter = children.slice(i + 1).some(node => !isNode(node, WhitespaceNode) && !isPureWhitespaceNode(node));
+                    if (hasNonWhitespaceAfter) {
+                        const previousNode = children[lastProcessedIndex];
+                        if (!isLineBreakingElement(previousNode)) {
+                            result.push({
+                                unit: { content: ' ', type: 'text', isAtomic: true, breaksFlow: false },
+                                node: child
+                            });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (isNode(child, HTMLTextNode)) {
+                this.processTextNode(result, children, child, i, lastProcessedIndex);
+                lastProcessedIndex = i;
+            }
+            else if (isNode(child, HTMLElementNode)) {
+                const tagName = getTagName(child);
+                if (isInlineElement(tagName)) {
+                    const merged = this.processInlineElement(result, children, child, i, lastProcessedIndex);
+                    if (merged) {
+                        lastProcessedIndex = i;
+                        continue;
                     }
                 }
-                finally {
-                    this.lines = oldLines;
-                    this.inlineMode = oldInlineMode;
+                else {
+                    result.push({
+                        unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+                        node: child
+                    });
                 }
+                lastProcessedIndex = i;
             }
-            else {
-                if (currentLineContent.trim()) {
-                    this.pushWithIndent(currentLineContent.trim());
-                    currentLineContent = "";
+            else if (isNode(child, ERBContentNode)) {
+                const merged = this.processERBContentNode(result, children, child, i, lastProcessedIndex);
+                if (merged) {
+                    lastProcessedIndex = i;
+                    continue;
                 }
-                this.visit(child);
+                lastProcessedIndex = i;
+            }
+            else {
+                result.push({
+                    unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+                    node: child
+                });
+                lastProcessedIndex = i;
             }
         }
-        if (currentLineContent.trim()) {
-            const finalLine = this.indent + currentLineContent.trim();
-            if (finalLine.length > Math.max(this.maxLineLength, 120)) {
-                this.visitAll(children);
-                return;
+        return result;
+    }
+    /**
+     * Flush accumulated words to output with wrapping
+     */
+    flushWords(words) {
+        if (words.length > 0) {
+            this.wrapAndPushWords(words);
+            words.length = 0;
+        }
+    }
+    /**
+     * Wrap words to fit within line length and push to output
+     * Handles punctuation spacing intelligently
+     * Excludes herb:disable comments from line length calculations
+     */
+    wrapAndPushWords(words) {
+        const wrapWidth = this.maxLineLength - this.indent.length;
+        const lines = [];
+        let currentLine = "";
+        let effectiveLength = 0;
+        for (const { word, isHerbDisable } of words) {
+            const nextLine = buildLineWithWord(currentLine, word);
+            let nextEffectiveLength = effectiveLength;
+            if (!isHerbDisable) {
+                const spaceBefore = currentLine && needsSpaceBetween(currentLine, word) ? 1 : 0;
+                nextEffectiveLength = effectiveLength + spaceBefore + word.length;
+            }
+            if (currentLine && !isClosingPunctuation(word) && nextEffectiveLength >= wrapWidth) {
+                lines.push(this.indent + currentLine.trimEnd());
+                currentLine = word;
+                effectiveLength = isHerbDisable ? 0 : word.length;
+            }
+            else {
+                currentLine = nextLine;
+                effectiveLength = nextEffectiveLength;
             }
-            this.push(finalLine);
         }
+        if (currentLine) {
+            lines.push(this.indent + currentLine.trimEnd());
+        }
+        lines.forEach(line => this.push(line));
     }
     isInTextFlowContext(_parent, children) {
         const hasTextContent = children.some(child => isNode(child, HTMLTextNode) && child.content.trim() !== "");
@@ -5048,7 +6151,7 @@ class FormatPrinter extends Printer {
             if (isNode(child, ERBContentNode))
                 return true;
             if (isNode(child, HTMLElementNode)) {
-                return this.isInlineElement(getTagName(child));
+                return isInlineElement(getTagName(child));
             }
             return false;
         });
@@ -5118,7 +6221,7 @@ class FormatPrinter extends Printer {
                 }
                 else {
                     const printed = IdentityPrinter.print(child);
-                    if (this.currentAttributeName && FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)) {
+                    if (this.isInTokenListAttribute) {
                         return printed.replace(/%>([^<\s])/g, '%> $1').replace(/([^>\s])<%/g, '$1 <%');
                     }
                     return printed;
@@ -5154,18 +6257,35 @@ class FormatPrinter extends Printer {
         let result = `<${tagName}`;
         result += this.renderAttributesString(attributes);
         result += ">";
-        const childrenContent = this.tryRenderChildrenInline(children);
+        const childrenContent = this.tryRenderChildrenInline(children, tagName);
         if (!childrenContent)
             return null;
         result += childrenContent;
         result += `</${tagName}>`;
         return result;
     }
+    /**
+     * Check if children contain a leading herb:disable comment (after optional whitespace)
+     */
+    hasLeadingHerbDisable(children) {
+        for (const child of children) {
+            if (isNode(child, WhitespaceNode) || (isNode(child, HTMLTextNode) && child.content.trim() === "")) {
+                continue;
+            }
+            return isNode(child, ERBContentNode) && isHerbDisableComment(child);
+        }
+        return false;
+    }
     /**
      * Try to render just the children inline (without tags)
      */
-    tryRenderChildrenInline(children) {
+    tryRenderChildrenInline(children, tagName) {
         let result = "";
+        let hasInternalWhitespace = false;
+        let addedLeadingSpace = false;
+        const hasHerbDisable = this.hasLeadingHerbDisable(children);
+        const hasOnlyTextContent = children.every(child => isNode(child, HTMLTextNode) || isNode(child, WhitespaceNode));
+        const shouldPreserveSpaces = hasOnlyTextContent && tagName && isInlineElement(tagName);
         for (const child of children) {
             if (isNode(child, HTMLTextNode)) {
                 const normalizedContent = child.content.replace(/\s+/g, ' ');
@@ -5173,36 +6293,53 @@ class FormatPrinter extends Printer {
                 const hasTrailingSpace = /\s$/.test(child.content);
                 const trimmedContent = normalizedContent.trim();
                 if (trimmedContent) {
-                    let finalContent = trimmedContent;
-                    if (hasLeadingSpace && result && !result.endsWith(' ')) {
-                        finalContent = ' ' + finalContent;
+                    if (hasLeadingSpace && (result || shouldPreserveSpaces) && !result.endsWith(' ')) {
+                        result += ' ';
                     }
+                    result += trimmedContent;
                     if (hasTrailingSpace) {
-                        finalContent = finalContent + ' ';
-                    }
-                    result += finalContent;
-                }
-                else if (hasLeadingSpace || hasTrailingSpace) {
-                    if (result && !result.endsWith(' ')) {
                         result += ' ';
                     }
+                    continue;
+                }
+            }
+            const isWhitespace = isNode(child, WhitespaceNode) || (isNode(child, HTMLTextNode) && child.content.trim() === "");
+            if (isWhitespace && !result.endsWith(' ')) {
+                if (!result && hasHerbDisable && !addedLeadingSpace) {
+                    result += ' ';
+                    addedLeadingSpace = true;
+                }
+                else if (result) {
+                    result += ' ';
+                    hasInternalWhitespace = true;
                 }
             }
             else if (isNode(child, HTMLElementNode)) {
                 const tagName = getTagName(child);
-                if (!this.isInlineElement(tagName)) {
+                if (!isInlineElement(tagName)) {
                     return null;
                 }
-                const childInline = this.tryRenderInlineFull(child, tagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), this.filterEmptyNodes(child.body));
+                const childrenToRender = this.getFilteredChildren(child.body);
+                const childInline = this.tryRenderInlineFull(child, tagName, filterNodes(child.open_tag?.children, HTMLAttributeNode), childrenToRender);
                 if (!childInline) {
                     return null;
                 }
                 result += childInline;
             }
-            else {
-                result += this.capture(() => this.visit(child)).join("");
+            else if (!isNode(child, HTMLTextNode) && !isWhitespace) {
+                const wasInlineMode = this.inlineMode;
+                this.inlineMode = true;
+                const captured = this.capture(() => this.visit(child)).join("");
+                this.inlineMode = wasInlineMode;
+                result += captured;
             }
         }
+        if (shouldPreserveSpaces) {
+            return result;
+        }
+        if (hasHerbDisable && result.startsWith(' ') || hasInternalWhitespace) {
+            return result.trimEnd();
+        }
         return result.trim();
     }
     /**
@@ -5217,8 +6354,7 @@ class FormatPrinter extends Printer {
                 }
             }
             else if (isNode(child, HTMLElementNode)) {
-                const isInlineElement = this.isInlineElement(getTagName(child));
-                if (!isInlineElement) {
+                if (!isInlineElement(getTagName(child))) {
                     return null;
                 }
             }
@@ -5234,103 +6370,14 @@ class FormatPrinter extends Printer {
         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 (isNode(child, HTMLElementNode)) {
-                if (this.isInlineElement(getTagName(child))) {
-                    hasInlineElements = true;
-                }
-            }
-        }
-        return (hasText && hasInlineElements) || (hasERBOutput(children) && hasText);
-    }
-    /**
-     * Check if children contain any text content with newlines
+     * Get filtered children, using smart herb:disable filtering if needed
      */
-    hasMultilineTextContent(children) {
-        for (const child of children) {
-            if (isNode(child, HTMLTextNode)) {
-                return child.content.includes('\n');
-            }
-            if (isNode(child, HTMLElementNode)) {
-                const nestedChildren = this.filterEmptyNodes(child.body);
-                if (this.hasMultilineTextContent(nestedChildren)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    /**
-     * Check if all nested elements in the children are inline elements
-     */
-    areAllNestedElementsInline(children) {
-        for (const child of children) {
-            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 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;
-        });
-    }
-    /**
-     * Filter out empty text nodes and whitespace nodes
-     */
-    filterEmptyNodes(nodes) {
-        return nodes.filter(child => !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === ""));
+    getFilteredChildren(body) {
+        const hasHerbDisable = body.some(child => isNode(child, ERBContentNode) && isHerbDisableComment(child));
+        return hasHerbDisable ? filterEmptyNodesForHerbDisable(body) : body;
     }
     renderElementInline(element) {
-        const children = this.filterEmptyNodes(element.body);
+        const children = this.getFilteredChildren(element.body);
         return this.renderChildrenInline(children);
     }
     renderChildrenInline(children) {
@@ -5352,9 +6399,29 @@ class FormatPrinter extends Printer {
         }
         return content.replace(/\s+/g, ' ').trim();
     }
-    isContentPreserving(element) {
-        const tagName = getTagName(element);
-        return FormatPrinter.CONTENT_PRESERVING_ELEMENTS.has(tagName);
+}
+
+const isScaffoldTemplate = (result) => {
+    const detector = new ScaffoldTemplateDetector();
+    detector.visit(result.value);
+    return detector.hasEscapedERB;
+};
+/**
+ * Visitor that detects if the AST represents a Rails scaffold template.
+ * Scaffold templates contain escaped ERB tags (<%%= or <%%)
+ * and should not be formatted to preserve their exact structure.
+ */
+class ScaffoldTemplateDetector extends Visitor {
+    hasEscapedERB = false;
+    visitERBContentNode(node) {
+        const opening = node.tag_opening?.value;
+        if (opening && opening.startsWith("<%%")) {
+            this.hasEscapedERB = true;
+            return;
+        }
+        if (this.hasEscapedERB)
+            return;
+        this.visitChildNodes(node);
     }
 }
 
@@ -5364,6 +6431,8 @@ class FormatPrinter extends Printer {
 const defaultFormatOptions = {
     indentWidth: 2,
     maxLineLength: 80,
+    preRewriters: [],
+    postRewriters: [],
 };
 /**
  * Merge provided options with defaults for any missing values.
@@ -5374,6 +6443,8 @@ function resolveFormatOptions(options = {}) {
     return {
         indentWidth: options.indentWidth ?? defaultFormatOptions.indentWidth,
         maxLineLength: options.maxLineLength ?? defaultFormatOptions.maxLineLength,
+        preRewriters: options.preRewriters ?? defaultFormatOptions.preRewriters,
+        postRewriters: options.postRewriters ?? defaultFormatOptions.postRewriters,
     };
 }
 
@@ -5384,6 +6455,30 @@ function resolveFormatOptions(options = {}) {
 class Formatter {
     herb;
     options;
+    /**
+     * Creates a Formatter instance from a Config object (recommended).
+     *
+     * @param herb - The Herb backend instance for parsing
+     * @param config - Optional Config instance for formatter options
+     * @param options - Additional options to override config
+     * @returns A configured Formatter instance
+     */
+    static from(herb, config, options = {}) {
+        const formatterConfig = config?.formatter || {};
+        const mergedOptions = {
+            indentWidth: options.indentWidth ?? formatterConfig.indentWidth,
+            maxLineLength: options.maxLineLength ?? formatterConfig.maxLineLength,
+            preRewriters: options.preRewriters,
+            postRewriters: options.postRewriters,
+        };
+        return new Formatter(herb, mergedOptions);
+    }
+    /**
+     * Creates a new Formatter instance.
+     *
+     * @param herb - The Herb backend instance for parsing
+     * @param options - Format options (including rewriters)
+     */
     constructor(herb, options = {}) {
         this.herb = herb;
         this.options = resolveFormatOptions(options);
@@ -5391,12 +6486,44 @@ class Formatter {
     /**
      * Format a source string, optionally overriding format options per call.
      */
-    format(source, options = {}) {
-        const result = this.parse(source);
+    format(source, options = {}, filePath) {
+        let result = this.parse(source);
         if (result.failed)
             return source;
+        if (isScaffoldTemplate(result))
+            return source;
         const resolvedOptions = resolveFormatOptions({ ...this.options, ...options });
-        return new FormatPrinter(source, resolvedOptions).print(result.value);
+        let node = result.value;
+        if (resolvedOptions.preRewriters.length > 0) {
+            const context = {
+                filePath,
+                baseDir: process.cwd() // TODO: format() shouldn't depend on node internals
+            };
+            for (const rewriter of resolvedOptions.preRewriters) {
+                try {
+                    node = rewriter.rewrite(node, context);
+                }
+                catch (error) {
+                    console.error(`Pre-format rewriter "${rewriter.name}" failed:`, error);
+                }
+            }
+        }
+        let formatted = new FormatPrinter(source, resolvedOptions).print(node);
+        if (resolvedOptions.postRewriters.length > 0) {
+            const context = {
+                filePath,
+                baseDir: process.cwd() // TODO: format() shouldn't depend on node internals
+            };
+            for (const rewriter of resolvedOptions.postRewriters) {
+                try {
+                    formatted = rewriter.rewrite(formatted, context);
+                }
+                catch (error) {
+                    console.error(`Post-format rewriter "${rewriter.name}" failed:`, error);
+                }
+            }
+        }
+        return formatted;
     }
     parse(source) {
         this.herb.ensureBackend();