@herb-tools/formatter 0.7.5 → 0.8.1

package/src/format-printer.ts

@@ -1,4 +1,7 @@
 import dedent from "dedent"
+
+import { Printer, IdentityPrinter } from "@herb-tools/printer"
+
 import {
   getTagName,
   getCombinedAttributeName,
@@ -6,15 +9,54 @@ import {
   isNode,
   isToken,
   isParseResult,
-  isAnyOf,
   isNoneOf,
   isERBNode,
   isCommentNode,
   isERBControlFlowNode,
   filterNodes,
-  hasERBOutput,
 } from "@herb-tools/core"
-import { Printer, IdentityPrinter } from "@herb-tools/printer"
+
+import {
+  areAllNestedElementsInline,
+  buildLineWithWord,
+  countAdjacentInlineElements,
+  endsWithWhitespace,
+  filterEmptyNodesForHerbDisable,
+  filterSignificantChildren,
+  findPreviousMeaningfulSibling,
+  hasComplexERBControlFlow,
+  hasMixedTextAndInlineContent,
+  hasMultilineTextContent,
+  hasWhitespaceBetween,
+  isBlockLevelNode,
+  isClosingPunctuation,
+  isContentPreserving,
+  isFrontmatter,
+  isHerbDisableComment,
+  isInlineElement,
+  isLineBreakingElement,
+  isNonWhitespaceNode,
+  isPureWhitespaceNode,
+  needsSpaceBetween,
+  normalizeAndSplitWords,
+  shouldAppendToLastLine,
+  shouldPreserveUserSpacing,
+} from "./format-helpers.js"
+
+import {
+  FORMATTABLE_ATTRIBUTES,
+  INLINE_ELEMENTS,
+  SPACEABLE_CONTAINERS,
+  SPACING_THRESHOLD,
+  TIGHT_GROUP_CHILDREN,
+  TIGHT_GROUP_PARENTS,
+  TOKEN_LIST_ATTRIBUTES,
+} from "./format-helpers.js"
+
+import type {
+  ContentUnitWithNode,
+  ElementFormattingAnalysis,
+} from "./format-helpers.js"
 
 import {
   ParseResult,
@@ -56,21 +98,6 @@ import {
 import type { ERBNode } from "@herb-tools/core"
 import type { FormatOptions } from "./options.js"
 
-/**
- * Analysis result for HTMLElementNode formatting decisions
- */
-interface ElementFormattingAnalysis {
-  openTagInline: boolean
-  elementContentInline: boolean
-  closeTagInline: boolean
-}
-
-// TODO: we can probably expand this list with more tags/attributes
-const FORMATTABLE_ATTRIBUTES: Record<string, string[]> = {
-  '*': ['class'],
-  'img': ['srcset', 'sizes']
-}
-
 /**
  * Printer traverses the Herb AST using the Visitor pattern
  * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
@@ -98,34 +125,6 @@ export class FormatPrinter extends Printer {
 
   public source: string
 
-  // TODO: extract
-  private static readonly 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'
-  ])
-
-  private static readonly CONTENT_PRESERVING_ELEMENTS = new Set([
-    'script', 'style', 'pre', 'textarea'
-  ])
-
-  private static readonly SPACEABLE_CONTAINERS = new Set([
-    'div', 'section', 'article', 'main', 'header', 'footer', 'aside',
-    'figure', 'details', 'summary', 'dialog', 'fieldset'
-  ])
-
-  private static readonly TIGHT_GROUP_PARENTS = new Set([
-    'ul', 'ol', 'nav', 'select', 'datalist', 'optgroup', 'tr', 'thead',
-    'tbody', 'tfoot'
-  ])
-
-  private static readonly TIGHT_GROUP_CHILDREN = new Set([
-    'li', 'option', 'td', 'th', 'dt', 'dd'
-  ])
-
-  private static readonly SPACING_THRESHOLD = 3
-
   constructor(source: string, options: Required<FormatOptions>) {
     super()
 
@@ -320,26 +319,26 @@ export class FormatPrinter extends Printer {
       return false
     }
 
-    const meaningfulSiblings = siblings.filter(child => this.isNonWhitespaceNode(child))
+    const meaningfulSiblings = siblings.filter(child => isNonWhitespaceNode(child))
 
-    if (meaningfulSiblings.length < FormatPrinter.SPACING_THRESHOLD) {
+    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) {
@@ -358,11 +357,11 @@ export 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
       }
 
@@ -371,56 +370,18 @@ export class FormatPrinter extends Printer {
       }
     }
 
-    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
-   */
-  private static readonly TOKEN_LIST_ATTRIBUTES = new Set([
-    'class', 'data-controller', 'data-action'
-  ])
-
   /**
    * Check if we're currently processing a token list attribute that needs spacing
    */
-  private isInTokenListAttribute(): boolean {
-    return this.currentAttributeName !== null &&
-           FormatPrinter.TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
-  }
-
-  /**
-   * Find the previous meaningful (non-whitespace) sibling
-   */
-  private findPreviousMeaningfulSibling(siblings: Node[], currentIndex: number): number {
-    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
-   */
-  private isBlockLevelNode(node: Node): boolean {
-    if (!isNode(node, HTMLElementNode)) {
-      return false
-    }
-
-    const tagName = getTagName(node)
-
-    if (FormatPrinter.INLINE_ELEMENTS.has(tagName)) {
-      return false
-    }
-
-    return true
+  private get isInTokenListAttribute(): boolean {
+    return this.currentAttributeName !== null && TOKEN_LIST_ATTRIBUTES.has(this.currentAttributeName)
   }
 
   /**
@@ -473,16 +434,13 @@ export class FormatPrinter extends Printer {
     return true
   }
 
-  private getAttributeName(attribute: HTMLAttributeNode): string {
-    return attribute.name ? getCombinedAttributeName(attribute.name) : ""
-  }
-
   private wouldClassAttributeBeMultiline(content: string, indentLength: number): boolean {
     const normalizedContent = content.replace(/\s+/g, ' ').trim()
     const hasActualNewlines = /\r?\n/.test(content)
 
     if (hasActualNewlines && normalizedContent.length > 80) {
       const lines = content.split(/\r?\n/).map(line => line.trim()).filter(line => line)
+
       if (lines.length > 1) {
         return true
       }
@@ -504,6 +462,12 @@ export class FormatPrinter extends Printer {
     return false
   }
 
+  // TOOD: extract to core or reuse function from core
+  private getAttributeName(attribute: HTMLAttributeNode): string {
+    return attribute.name ? getCombinedAttributeName(attribute.name) : ""
+  }
+
+  // TOOD: extract to core or reuse function from core
   private getAttributeValue(attribute: HTMLAttributeNode): string {
     if (isNode(attribute.value, HTMLAttributeValueNode)) {
       return attribute.value.children.map(child => isNode(child, HTMLTextNode) ? child.content : IdentityPrinter.print(child)).join('')
@@ -674,37 +638,50 @@ export class FormatPrinter extends Printer {
   // --- Visitor methods ---
 
   visitDocumentNode(node: DocumentNode) {
-    let lastWasMeaningful = false
-    let hasHandledSpacing = false
+    const children = this.formatFrontmatter(node)
+    const hasTextFlow = this.isInTextFlowContext(null, children)
 
-    for (let i = 0; i < node.children.length; i++) {
-      const child = node.children[i]
+    if (hasTextFlow) {
+      const wasInlineMode = this.inlineMode
+      this.inlineMode = true
 
-      if (isNode(child, HTMLTextNode)) {
-        const isWhitespaceOnly = child.content.trim() === ""
+      this.visitTextFlowChildren(children)
 
-        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])
+      this.inlineMode = wasInlineMode
 
-          const hasMultipleNewlines = child.content.includes('\n\n')
+      return
+    }
 
-          if (hasPreviousNonWhitespace && hasNextNonWhitespace && hasMultipleNewlines) {
-            this.push("")
-            hasHandledSpacing = true
-          }
+    let lastWasMeaningful = false
+    let hasHandledSpacing = false
 
-          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
       }
@@ -715,6 +692,14 @@ export class FormatPrinter extends Printer {
     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) {
@@ -729,7 +714,9 @@ export class FormatPrinter extends Printer {
   }
 
   visitHTMLElementBody(body: Node[], element: HTMLElementNode) {
-    if (this.isContentPreserving(element)) {
+    const tagName = getTagName(element)
+
+    if (isContentPreserving(element)) {
       element.body.map(child => {
         if (isNode(child, HTMLElementNode)) {
           const wasInlineMode = this.inlineMode
@@ -749,7 +736,7 @@ export 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
@@ -757,6 +744,9 @@ export class FormatPrinter extends Printer {
       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(() => {
@@ -771,10 +761,18 @@ export class FormatPrinter extends Printer {
                 this.push(' ')
               }
             } else {
-              const normalizedContent = child.content.replace(/\s+/g, ' ').trim()
+              const normalizedContent = child.content.replace(/\s+/g, ' ')
 
-              if (normalizedContent) {
+              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)) {
@@ -786,7 +784,10 @@ export 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)
@@ -799,11 +800,83 @@ export class FormatPrinter extends Printer {
 
     if (children.length === 0) return
 
+    let leadingHerbDisableComment: Node | null = 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)
       }
     })
   }
@@ -822,8 +895,8 @@ export class FormatPrinter extends Printer {
         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')
 
@@ -836,7 +909,7 @@ export class FormatPrinter extends Printer {
         }
       }
 
-      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)
 
@@ -852,9 +925,46 @@ export class FormatPrinter extends Printer {
         }
       }
 
-      this.visit(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)
 
-      if (this.isNonWhitespaceNode(child)) {
+            i = j
+
+            break
+          }
+
+          break
+        }
+      }
+
+      if (!hasTrailingHerbDisable) {
+        this.visit(child)
+      }
+
+      if (isNonWhitespaceNode(child)) {
         lastWasMeaningful = true
         hasHandledSpacing = false
       }
@@ -970,8 +1080,8 @@ export class FormatPrinter extends Printer {
       inner = node.children.map(child => {
         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 ""
         }
@@ -1035,13 +1145,22 @@ export class FormatPrinter extends Printer {
       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
     }
 
@@ -1093,6 +1212,8 @@ export class FormatPrinter extends Printer {
 
   visitERBCaseMatchNode(node: ERBCaseMatchNode) {
     this.printERBNode(node)
+
+    this.withIndent(() => this.visitAll(node.children))
     this.visitAll(node.conditions)
 
     if (node.else_clause) this.visit(node.else_clause)
@@ -1101,7 +1222,16 @@ export class FormatPrinter extends Printer {
 
   visitERBBlockNode(node: ERBBlockNode) {
     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)
   }
@@ -1115,7 +1245,7 @@ export class FormatPrinter extends Printer {
           this.lines.push(" ")
           this.lines.push(this.renderAttribute(child))
         } else {
-          const shouldAddSpaces = this.isInTokenListAttribute()
+          const shouldAddSpaces = this.isInTokenListAttribute
 
           if (shouldAddSpaces) {
             this.lines.push(" ")
@@ -1130,13 +1260,13 @@ export 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)
+      if (node.subsequent) this.visit(node.subsequent)
       if (node.end_node) this.visit(node.end_node)
     } else {
       this.printERBNode(node)
@@ -1151,8 +1281,13 @@ export class FormatPrinter extends Printer {
   }
 
   visitERBElseNode(node: ERBElseNode) {
-    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: ERBWhenNode) {
@@ -1162,6 +1297,8 @@ export class FormatPrinter extends Printer {
 
   visitERBCaseNode(node: ERBCaseNode) {
     this.printERBNode(node)
+
+    this.withIndent(() => this.visitAll(node.children))
     this.visitAll(node.conditions)
 
     if (node.else_clause) this.visit(node.else_clause)
@@ -1242,7 +1379,7 @@ export 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
 
@@ -1275,15 +1412,30 @@ export class FormatPrinter extends Printer {
    */
   private shouldRenderElementContentInline(node: HTMLElementNode): boolean {
     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
@@ -1293,12 +1445,12 @@ export class FormatPrinter extends Printer {
       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
@@ -1337,9 +1489,9 @@ export class FormatPrinter extends Printer {
   private shouldRenderCloseTagInline(node: HTMLElementNode, elementContentInline: boolean): boolean {
     if (node.is_void) return true
     if (node.open_tag?.tag_closing?.value === "/>") return true
-    if (this.isContentPreserving(node)) return true
+    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
 
@@ -1349,152 +1501,693 @@ export class FormatPrinter extends Printer {
 
   // --- Utility methods ---
 
-  private isNonWhitespaceNode(node: Node): boolean {
-    if (isNode(node, WhitespaceNode)) return false
-    if (isNode(node, HTMLTextNode)) return node.content.trim() !== ""
+  private formatFrontmatter(node: DocumentNode): Node[] {
+    const firstChild = node.children[0]
+    const hasFrontmatter = firstChild && isFrontmatter(firstChild)
 
-    return true
+    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
    */
-  private isInlineElement(tagName: string): boolean {
-    return FormatPrinter.INLINE_ELEMENTS.has(tagName.toLowerCase())
+  private appendChildToLastLine(child: Node, siblings?: Node[], index?: number): void {
+    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
    */
   private visitTextFlowChildren(children: Node[]) {
-    let currentLineContent = ""
-
-    for (const child of children) {
-      if (isNode(child, HTMLTextNode)) {
-        const content = child.content
+    const adjacentInlineCount = countAdjacentInlineElements(children)
 
-        let processedContent = content.replace(/\s+/g, ' ').trim()
+    if (adjacentInlineCount >= 2) {
+      const { processedIndices } = this.renderAdjacentInlineElements(children, adjacentInlineCount)
+      this.visitRemainingChildren(children, processedIndices)
 
-        if (processedContent) {
-          const hasLeadingSpace = /^\s/.test(content)
-
-          if (currentLineContent && hasLeadingSpace && !currentLineContent.endsWith(' ')) {
-            currentLineContent += ' '
-          }
+      return
+    }
 
-          currentLineContent += processedContent
+    this.buildAndWrapTextFlow(children)
+  }
 
-          const hasTrailingSpace = /\s$/.test(content)
+  /**
+   * Wrap remaining words that don't fit on the current line
+   * Returns the wrapped lines with proper indentation
+   */
+  private wrapRemainingWords(words: string[], wrapWidth: number): string[] {
+    const lines: string[] = []
+    let line = ""
 
-          if (hasTrailingSpace && !currentLineContent.endsWith(' ')) {
-            currentLineContent += ' '
-          }
+    for (const word of words) {
+      const testLine = line + (line ? " " : "") + word
 
-          if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-            children.forEach(child => this.visit(child))
+      if (testLine.length > wrapWidth && line) {
+        lines.push(this.indent + line)
+        line = word
+      } else {
+        line = testLine
+      }
+    }
 
-            return
-          }
-        }
-      } else if (isNode(child, HTMLElementNode)) {
-        const childTagName = getTagName(child)
+    if (line) {
+      lines.push(this.indent + line)
+    }
 
-        if (this.isInlineElement(childTagName)) {
-          const childInline = this.tryRenderInlineFull(child, childTagName,
-            filterNodes(child.open_tag?.children, HTMLAttributeNode),
-            this.filterEmptyNodes(child.body)
-          )
+    return lines
+  }
 
-          if (childInline) {
-            currentLineContent += childInline
+  /**
+   * Try to merge text starting with punctuation to inline content
+   * Returns object with merged content and whether processing should stop
+   */
+  private tryMergePunctuationText(inlineContent: string, trimmedText: string, wrapWidth: number): { mergedContent: string, shouldStop: boolean, wrappedLines: string[] } {
+    const combined = inlineContent + trimmedText
+
+    if (combined.length <= wrapWidth) {
+      return {
+        mergedContent: inlineContent + trimmedText,
+        shouldStop: false,
+        wrappedLines: []
+      }
+    }
 
-            if ((this.indent.length + currentLineContent.length) > this.maxLineLength) {
-              children.forEach(child => this.visit(child))
+    const match = trimmedText.match(/^[.!?:;]+/)
 
-              return
-            }
-          } else {
-            if (currentLineContent.trim()) {
-              this.pushWithIndent(currentLineContent.trim())
-              currentLineContent = ""
-            }
+    if (!match) {
+      return {
+        mergedContent: inlineContent,
+        shouldStop: false,
+        wrappedLines: []
+      }
+    }
 
-            this.visit(child)
-          }
-        } else {
-          if (currentLineContent.trim()) {
-            this.pushWithIndent(currentLineContent.trim())
-            currentLineContent = ""
-          }
+    const punctuation = match[0]
+    const restText = trimmedText.substring(punctuation.length).trim()
 
-          this.visit(child)
-        }
-      } else if (isNode(child, ERBContentNode)) {
-        const oldLines = this.lines
-        const oldInlineMode = this.inlineMode
+    if (!restText) {
+      return {
+        mergedContent: inlineContent + punctuation,
+        shouldStop: false,
+        wrappedLines: []
+      }
+    }
 
-        // TODO: use this.capture
-        try {
-          this.lines = []
-          this.inlineMode = true
-          this.visit(child)
-          const erbContent = this.lines.join("")
-          currentLineContent += erbContent
+    const words = restText.split(/\s+/)
+    let toMerge = punctuation
+    let mergedWordCount = 0
 
-          if ((this.indent.length + currentLineContent.length) > Math.max(this.maxLineLength, 120)) {
-            this.lines = oldLines
-            this.inlineMode = oldInlineMode
-            children.forEach(child => this.visit(child))
+    for (const word of words) {
+      const testMerge = toMerge + ' ' + word
 
-            return
-          }
-        } finally {
-          this.lines = oldLines
-          this.inlineMode = oldInlineMode
-        }
+      if ((inlineContent + testMerge).length <= wrapWidth) {
+        toMerge = testMerge
+        mergedWordCount++
       } else {
-        if (currentLineContent.trim()) {
-          this.pushWithIndent(currentLineContent.trim())
-          currentLineContent = ""
-        }
-
-        this.visit(child)
+        break
       }
     }
 
-    if (currentLineContent.trim()) {
-      const finalLine = this.indent + currentLineContent.trim()
-
-      if (finalLine.length > Math.max(this.maxLineLength, 120)) {
-        this.visitAll(children)
+    const mergedContent = inlineContent + toMerge
 
-        return
+    if (mergedWordCount >= words.length) {
+      return {
+        mergedContent,
+        shouldStop: false,
+        wrappedLines: []
       }
+    }
 
-      this.push(finalLine)
+    const remainingWords = words.slice(mergedWordCount)
+    const wrappedLines = this.wrapRemainingWords(remainingWords, wrapWidth)
+
+    return {
+      mergedContent,
+      shouldStop: true,
+      wrappedLines
     }
   }
 
-  private isInTextFlowContext(_parent: Node | null, children: Node[]): boolean {
-    const hasTextContent = children.some(child => isNode(child, HTMLTextNode) &&child.content.trim() !== "")
-    const nonTextChildren = children.filter(child => !isNode(child, HTMLTextNode))
-
-    if (!hasTextContent) return false
-    if (nonTextChildren.length === 0) return false
+  /**
+   * Render adjacent inline elements together on one line
+   */
+  private renderAdjacentInlineElements(children: Node[], count: number): { processedIndices: Set<number> } {
+    let inlineContent = ""
+    let processedCount = 0
+    let lastProcessedIndex = -1
+    const processedIndices = new Set<number>()
 
-    const allInline = nonTextChildren.every(child => {
-      if (isNode(child, ERBContentNode)) return true
+    for (let index = 0; index < children.length && processedCount < count; index++) {
+      const child = children[index]
 
-      if (isNode(child, HTMLElementNode)) {
-        return this.isInlineElement(getTagName(child))
+      if (isPureWhitespaceNode(child) || isNode(child, WhitespaceNode)) {
+        continue
       }
 
-      return false
-    })
-
-    if (!allInline) return false
+      if (isNode(child, HTMLElementNode) && isInlineElement(getTagName(child))) {
+        inlineContent += this.renderInlineElementAsString(child)
+        processedCount++
+        lastProcessedIndex = index
+        processedIndices.add(index)
 
-    return true
+        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
+      }
+    }
+
+    if (inlineContent) {
+      this.pushWithIndent(inlineContent)
+    }
+
+    return { processedIndices }
+  }
+
+  /**
+   * Render an inline element as a string
+   */
+  private renderInlineElementAsString(element: HTMLElementNode): string {
+    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
+   */
+  private renderERBAsString(node: ERBContentNode): string {
+    return this.capture(() => {
+      this.inlineMode = true
+      this.visit(node)
+    }).join("")
+  }
+
+  /**
+   * Visit remaining children after processing adjacent inline elements
+   */
+  private visitRemainingChildren(children: Node[], processedIndices: Set<number>): void {
+    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
+   */
+  private buildAndWrapTextFlow(children: Node[]): void {
+    const unitsWithNodes: ContentUnitWithNode[] = this.buildContentUnitsWithNodes(children)
+    const words: Array<{ word: string, isHerbDisable: boolean }> = []
+
+    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 += ' '
+            }
+          }
+
+          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 += ' '
+            }
+          }
+        } else if (text === ' ' && words.length > 0) {
+          const lastWord = words[words.length - 1]
+
+          if (!lastWord.word.endsWith(' ')) {
+            lastWord.word += ' '
+          }
+        }
+      }
+    }
+
+    this.flushWords(words)
+  }
+
+  /**
+   * Try to merge text that follows an atomic unit (ERB/inline) with no whitespace
+   * Returns true if merge was performed
+   */
+  private tryMergeTextAfterAtomic(result: ContentUnitWithNode[], textNode: HTMLTextNode): boolean {
+    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 (/\s/.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
+      })
+    } else if (endsWithWhitespace(textNode.content)) {
+      result.push({
+        unit: { content: ' ', 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
+   */
+  private tryMergeAtomicAfterText(result: ContentUnitWithNode[], children: Node[], lastProcessedIndex: number, atomicContent: string, atomicType: 'erb' | 'inline', atomicNode: Node): boolean {
+    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
+   */
+  private hasWhitespaceBeforeNode(children: Node[], lastProcessedIndex: number, currentIndex: number, currentNode: Node): boolean {
+    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
+   */
+  private lastUnitEndsWithWhitespace(result: ContentUnitWithNode[]): boolean {
+    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)
+   */
+  private processTextNode(result: ContentUnitWithNode[], children: Node[], child: HTMLTextNode, index: number, lastProcessedIndex: number): void {
+    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')
+
+      if (lastIsAtomic && !hasWhitespace && 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)
+   */
+  private processInlineElement(result: ContentUnitWithNode[], children: Node[], child: HTMLElementNode, index: number, lastProcessedIndex: number): boolean {
+    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)
+   */
+  private processERBContentNode(result: ContentUnitWithNode[], children: Node[], child: ERBContentNode, index: number, lastProcessedIndex: number): boolean {
+    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
+   */
+  private buildContentUnitsWithNodes(children: Node[]): ContentUnitWithNode[] {
+    const result: ContentUnitWithNode[] = []
+    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
+          }
+        } else {
+          result.push({
+            unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+            node: child
+          })
+        }
+
+        lastProcessedIndex = i
+      } else if (isNode(child, ERBContentNode)) {
+        const merged = this.processERBContentNode(result, children, child, i, lastProcessedIndex)
+
+        if (merged) {
+          lastProcessedIndex = i
+
+          continue
+        }
+
+        lastProcessedIndex = i
+      } else {
+        result.push({
+          unit: { content: '', type: 'block', isAtomic: false, breaksFlow: true },
+          node: child
+        })
+
+        lastProcessedIndex = i
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Flush accumulated words to output with wrapping
+   */
+  private flushWords(words: Array<{ word: string, isHerbDisable: boolean }>): void {
+    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
+   */
+  private wrapAndPushWords(words: Array<{ word: string, isHerbDisable: boolean }>): void {
+    const wrapWidth = this.maxLineLength - this.indent.length
+    const lines: string[] = []
+    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
+      }
+    }
+
+    if (currentLine) {
+      lines.push(this.indent + currentLine.trimEnd())
+    }
+
+    lines.forEach(line => this.push(line))
+  }
+
+  private isInTextFlowContext(_parent: Node | null, children: Node[]): boolean {
+    const hasTextContent = children.some(child => isNode(child, HTMLTextNode) &&child.content.trim() !== "")
+    const nonTextChildren = children.filter(child => !isNode(child, HTMLTextNode))
+
+    if (!hasTextContent) return false
+    if (nonTextChildren.length === 0) return false
+
+    const allInline = nonTextChildren.every(child => {
+      if (isNode(child, ERBContentNode)) return true
+
+      if (isNode(child, HTMLElementNode)) {
+        return isInlineElement(getTagName(child))
+      }
+
+      return false
+    })
+
+    if (!allInline) return false
+
+    return true
   }
 
   private renderInlineOpen(name: string, attributes: HTMLAttributeNode[], selfClose: boolean, inlineNodes: Node[] = [], allChildren: Node[] = []): string {
@@ -1576,7 +2269,7 @@ export 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 <%')
           }
 
@@ -1617,7 +2310,7 @@ export class FormatPrinter extends Printer {
     result += this.renderAttributesString(attributes)
     result += ">"
 
-    const childrenContent = this.tryRenderChildrenInline(children)
+    const childrenContent = this.tryRenderChildrenInline(children, tagName)
 
     if (!childrenContent) return null
 
@@ -1627,11 +2320,32 @@ export class FormatPrinter extends Printer {
     return result
   }
 
+  /**
+   * Check if children contain a leading herb:disable comment (after optional whitespace)
+   */
+  private hasLeadingHerbDisable(children: Node[]): boolean {
+    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)
    */
-  private tryRenderChildrenInline(children: Node[]): string | null {
+  private tryRenderChildrenInline(children: Node[], tagName?: string): string | null {
     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)) {
@@ -1641,33 +2355,41 @@ export class FormatPrinter extends Printer {
         const trimmedContent = normalizedContent.trim()
 
         if (trimmedContent) {
-          let finalContent = trimmedContent
-
-          if (hasLeadingSpace && result && !result.endsWith(' ')) {
-            finalContent = ' ' + finalContent
+          if (hasLeadingSpace && (result || shouldPreserveSpaces) && !result.endsWith(' ')) {
+            result += ' '
           }
 
-          if (hasTrailingSpace) {
-            finalContent = finalContent + ' '
-          }
+          result += trimmedContent
 
-          result += finalContent
-        } else if (hasLeadingSpace || hasTrailingSpace) {
-          if (result && !result.endsWith(' ')) {
+          if (hasTrailingSpace) {
             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 childrenToRender = this.getFilteredChildren(child.body)
         const childInline = this.tryRenderInlineFull(child, tagName,
           filterNodes(child.open_tag?.children, HTMLAttributeNode),
-          this.filterEmptyNodes(child.body)
+          childrenToRender
         )
 
         if (!childInline) {
@@ -1675,11 +2397,23 @@ export class FormatPrinter extends Printer {
         }
 
         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()
   }
 
@@ -1694,9 +2428,7 @@ export class FormatPrinter extends Printer {
           return null
         }
       } else if (isNode(child, HTMLElementNode)) {
-        const isInlineElement = this.isInlineElement(getTagName(child))
-
-        if (!isInlineElement) {
+        if (!isInlineElement(getTagName(child))) {
           return null
         }
       } else if (isNode(child, ERBContentNode)) {
@@ -1716,121 +2448,18 @@ export class FormatPrinter extends Printer {
   }
 
   /**
-   * 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
-   */
-  private hasMixedTextAndInlineContent(children: Node[]): boolean {
-    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
-   */
-  private hasMultilineTextContent(children: Node[]): boolean {
-    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
-   */
-  private areAllNestedElementsInline(children: Node[]): boolean {
-    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
-   */
-  private hasComplexERBControlFlow(inlineNodes: Node[]): boolean {
-    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
+   * Get filtered children, using smart herb:disable filtering if needed
    */
-  private filterSignificantChildren(body: Node[], hasTextFlow: boolean): Node[] {
-    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
-   */
-  private filterEmptyNodes(nodes: Node[]): Node[] {
-    return nodes.filter(child =>
-      !isNode(child, WhitespaceNode) && !(isNode(child, HTMLTextNode) && child.content.trim() === "")
+  private getFilteredChildren(body: Node[]): Node[] {
+    const hasHerbDisable = body.some(child =>
+      isNode(child, ERBContentNode) && isHerbDisableComment(child)
     )
+
+    return hasHerbDisable ? filterEmptyNodesForHerbDisable(body) : body
   }
 
   private renderElementInline(element: HTMLElementNode): string {
-    const children = this.filterEmptyNodes(element.body)
+    const children = this.getFilteredChildren(element.body)
 
     return this.renderChildrenInline(children)
   }
@@ -1855,10 +2484,4 @@ export class FormatPrinter extends Printer {
 
     return content.replace(/\s+/g, ' ').trim()
   }
-
-  private isContentPreserving(element: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): boolean {
-    const tagName = getTagName(element)
-
-    return FormatPrinter.CONTENT_PRESERVING_ELEMENTS.has(tagName)
-  }
 }