@herb-tools/formatter 0.8.9 → 0.9.0

package/dist/types/attribute-renderer.d.ts

@@ -0,0 +1,44 @@
+import { HTMLAttributeNode } from "@herb-tools/core";
+import type { ERBNode } from "@herb-tools/core";
+/**
+ * Interface that the delegate must implement to provide
+ * ERB reconstruction capabilities to the AttributeRenderer.
+ */
+export interface AttributeRendererDelegate {
+    reconstructERBNode(node: ERBNode, withFormatting: boolean): string;
+}
+/**
+ * AttributeRenderer converts HTMLAttributeNode AST nodes into formatted strings.
+ * It handles class attribute wrapping, multiline attribute formatting,
+ * quote normalization, and token list attribute spacing.
+ */
+export declare class AttributeRenderer {
+    private delegate;
+    private maxLineLength;
+    private indentWidth;
+    currentAttributeName: string | null;
+    indentLevel: number;
+    constructor(delegate: AttributeRendererDelegate, maxLineLength: number, indentWidth: number);
+    /**
+     * Check if we're currently processing a token list attribute that needs spacing
+     */
+    get isInTokenListAttribute(): boolean;
+    /**
+     * Render attributes as a space-separated string
+     */
+    renderAttributesString(attributes: HTMLAttributeNode[], tagName: string): string;
+    /**
+     * Determine if a tag should be rendered inline based on attribute count and other factors
+     */
+    shouldRenderInline(totalAttributeCount: number, inlineLength: number, indentLength: number, maxLineLength?: number, hasComplexERB?: boolean, hasMultilineAttributes?: boolean, attributes?: HTMLAttributeNode[]): boolean;
+    wouldClassAttributeBeMultiline(content: string, indentLength: number): boolean;
+    getAttributeName(attribute: HTMLAttributeNode): string;
+    getAttributeValue(attribute: HTMLAttributeNode): string;
+    hasMultilineAttributes(attributes: HTMLAttributeNode[]): boolean;
+    formatClassAttribute(content: string, name: string, equals: string, open_quote: string, close_quote: string): string;
+    isFormattableAttribute(attributeName: string, tagName: string): boolean;
+    formatMultilineAttribute(content: string, name: string, open_quote: string, close_quote: string): string;
+    formatMultilineAttributeValue(lines: string[]): string;
+    breakTokensIntoLines(tokens: string[], currentIndent: number, separator?: string): string[];
+    renderAttribute(attribute: HTMLAttributeNode, tagName: string): string;
+}

package/dist/types/cli.d.ts

@@ -1,4 +1,6 @@
 export declare class CLI {
+    protected projectPath: string;
+    protected determineProjectPath(patterns: string[]): void;
     private usage;
     private parseArguments;
     run(): Promise<void>;

package/dist/types/comment-helpers.d.ts

@@ -0,0 +1,45 @@
+import { Node } from "@herb-tools/core";
+/**
+ * Result of formatting an ERB comment.
+ * - `single-line`: the caller emits the text on a single line (using push or pushWithIndent)
+ * - `multi-line`: the caller emits header, indented content lines, and footer separately
+ */
+export type ERBCommentResult = {
+    type: 'single-line';
+    text: string;
+} | {
+    type: 'multi-line';
+    header: string;
+    contentLines: string[];
+    footer: string;
+};
+/**
+ * Extract the raw inner text from HTML comment children.
+ * Joins text/literal nodes by content and ERB nodes via IdentityPrinter.
+ */
+export declare function extractHTMLCommentContent(children: Node[]): string;
+/**
+ * Format the inner content of an HTML comment.
+ *
+ * Handles three cases:
+ * 1. IE conditional comments (`[if ...` / `<![endif]`) — returned as-is
+ * 2. Multiline comments — re-indented with relative indent preservation
+ * 3. Single-line comments — wrapped with spaces: ` content `
+ *
+ * Returns null for IE conditional comments to signal the caller
+ * should emit the raw content without reformatting.
+ *
+ * @param rawInner - The joined children content string (may be empty)
+ * @param indentWidth - Number of spaces per indent level
+ * @returns The formatted inner string, or null if rawInner is empty-ish
+ */
+export declare function formatHTMLCommentInner(rawInner: string, indentWidth: number): string;
+/**
+ * Format an ERB comment into either a single-line or multi-line result.
+ *
+ * @param open - The opening tag (e.g. "<%#")
+ * @param content - The raw content string between open/close tags
+ * @param close - The closing tag (e.g. "%>")
+ * @returns A discriminated union describing how to render the comment
+ */
+export declare function formatERBCommentLines(open: string, content: string, close: string): ERBCommentResult;

package/dist/types/format-helpers.d.ts

@@ -25,19 +25,17 @@ export interface ContentUnitWithNode {
     unit: ContentUnit;
     node: Node | null;
 }
+/**
+ * ASCII whitespace pattern - use instead of \s to preserve Unicode whitespace
+ * characters like NBSP (U+00A0) and full-width space (U+3000)
+ */
+export declare const ASCII_WHITESPACE: RegExp;
 export declare const FORMATTABLE_ATTRIBUTES: Record<string, string[]>;
 export declare const INLINE_ELEMENTS: Set<string>;
 export declare const CONTENT_PRESERVING_ELEMENTS: Set<string>;
+export declare const WHITESPACE_PRESERVING_CLASSES: string[];
+export declare const WHITESPACE_PRESERVING_STYLE_VALUES: Set<string>;
 export declare const SPACEABLE_CONTAINERS: Set<string>;
-/**
- * Token list attributes that contain space-separated values and benefit from
- * spacing around ERB content for readability
- */
-export declare const TOKEN_LIST_ATTRIBUTES: Set<string>;
-/**
- * Check if a node is pure whitespace (empty text node with only whitespace)
- */
-export declare function isPureWhitespaceNode(node: Node): boolean;
 /**
  * Check if a node is non-whitespace (has meaningful content)
  */
@@ -125,11 +123,13 @@ export declare function hasComplexERBControlFlow(inlineNodes: Node[]): boolean;
  * This indicates content that should be formatted inline even with structural newlines
  */
 export declare function hasMixedTextAndInlineContent(children: Node[]): boolean;
+export declare function hasWhitespacePreservingStyle(element: HTMLElementNode): boolean;
 export declare function isContentPreserving(element: HTMLElementNode | HTMLOpenTagNode | HTMLCloseTagNode): boolean;
 /**
- * Count consecutive inline elements/ERB at the start of children (with no whitespace between)
+ * Count consecutive inline elements/ERB with no whitespace between them.
+ * Starts from startIndex and skips indices in processedIndices.
  */
-export declare function countAdjacentInlineElements(children: Node[]): number;
+export declare function countAdjacentInlineElements(children: Node[], startIndex?: number, processedIndices?: Set<number>): number;
 /**
  * Check if a node represents a block-level element
  */
@@ -151,6 +151,10 @@ export declare function endsWithWhitespace(text: string): boolean;
  * Check if an ERB content node is a herb:disable comment
  */
 export declare function isHerbDisableComment(node: Node): boolean;
+/**
+ * Check if children contain a leading herb:disable comment (after optional whitespace)
+ */
+export declare function hasLeadingHerbDisable(children: Node[]): boolean;
 /**
  * Check if a text node is YAML frontmatter (starts and ends with ---)
  */

package/dist/types/format-printer.d.ts

@@ -1,12 +1,14 @@
 import { Printer } from "@herb-tools/printer";
-import { ParseResult, Node, DocumentNode, HTMLOpenTagNode, HTMLCloseTagNode, HTMLElementNode, HTMLAttributeNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, ERBContentNode, ERBBlockNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode, XMLDeclarationNode, CDATANode, Token } from "@herb-tools/core";
 import type { ERBNode } from "@herb-tools/core";
 import type { FormatOptions } from "./options.js";
+import type { TextFlowDelegate } from "./text-flow-engine.js";
+import type { AttributeRendererDelegate } from "./attribute-renderer.js";
+import { ParseResult, Node, DocumentNode, HTMLOpenTagNode, HTMLConditionalOpenTagNode, HTMLCloseTagNode, HTMLElementNode, HTMLConditionalElementNode, HTMLAttributeNode, HTMLAttributeValueNode, HTMLAttributeNameNode, HTMLTextNode, HTMLCommentNode, HTMLDoctypeNode, ERBContentNode, ERBBlockNode, ERBEndNode, ERBElseNode, ERBIfNode, ERBWhenNode, ERBCaseNode, ERBCaseMatchNode, ERBWhileNode, ERBUntilNode, ERBForNode, ERBRescueNode, ERBEnsureNode, ERBBeginNode, ERBUnlessNode, ERBYieldNode, ERBInNode, ERBOpenTagNode, HTMLVirtualCloseTagNode, XMLDeclarationNode, CDATANode, Token } from "@herb-tools/core";
 /**
  * Printer traverses the Herb AST using the Visitor pattern
  * and emits a formatted string with proper indentation, line breaks, and attribute wrapping.
  */
-export declare class FormatPrinter extends Printer {
+export declare class FormatPrinter extends Printer implements TextFlowDelegate, AttributeRendererDelegate {
     /**
      * @deprecated integrate indentWidth into this.options and update FormatOptions to extend from @herb-tools/printer options
      */
@@ -14,20 +16,22 @@ export declare class FormatPrinter extends Printer {
     /**
      * @deprecated integrate maxLineLength into this.options and update FormatOptions to extend from @herb-tools/printer options
      */
-    private maxLineLength;
+    maxLineLength: number;
     /**
      * @deprecated refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
      */
     private lines;
     private indentLevel;
     private inlineMode;
-    private currentAttributeName;
+    private inContentPreservingContext;
+    private inConditionalOpenTagContext;
     private elementStack;
     private elementFormattingAnalysis;
     private nodeIsMultiline;
     private stringLineCount;
-    private tagGroupsCache;
-    private allSingleLineCache;
+    private textFlow;
+    private attributeRenderer;
+    private spacingAnalyzer;
     source: string;
     constructor(source: string, options: Required<FormatOptions>);
     print(input: Node | ParseResult | Token): string;
@@ -60,16 +64,19 @@ export declare class FormatPrinter extends Printer {
     /**
      * @deprecated refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
      */
-    private push;
+    push(line: string): void;
     /**
      * @deprecated refactor to use @herb-tools/printer infrastructre (or rework printer use push and this.lines)
      */
-    private pushWithIndent;
+    pushWithIndent(line: string): void;
     private withIndent;
-    private get indent();
+    private withInlineMode;
+    private withContentPreserving;
+    get indent(): string;
     /**
      * Format ERB content with proper spacing around the inner content.
-     * Returns empty string if content is empty, otherwise wraps content with single spaces.
+     * Returns empty string if content is empty, otherwise adds a leading space
+     * and a trailing space (or newline for heredoc content starting with "<<").
      */
     private formatERBContent;
     /**
@@ -80,56 +87,6 @@ export declare class FormatPrinter extends Printer {
      * Extract inline nodes (non-attribute, non-whitespace) from a list of nodes
      */
     private extractInlineNodes;
-    /**
-     * Check if a node will render as multiple lines when formatted.
-     */
-    private isMultilineElement;
-    /**
-     * Get a grouping key for a node (tag name for HTML, ERB type for ERB)
-     */
-    private getGroupingKey;
-    /**
-     * Detect groups of consecutive same-tag/same-type single-line elements
-     * Returns a map of index -> group info for efficient lookup
-     */
-    private detectTagGroups;
-    /**
-     * Determine if spacing should be added between sibling elements
-     *
-     * This implements the "rule of three" intelligent spacing system:
-     * - Adds spacing between 3 or more meaningful siblings
-     * - Respects semantic groupings (e.g., ul/li, nav/a stay tight)
-     * - Groups comments with following elements
-     * - Preserves user-added spacing
-     *
-     * @param parentElement - The parent element containing the siblings
-     * @param siblings - Array of all sibling nodes
-     * @param currentIndex - Index of the current node being evaluated
-     * @param hasExistingSpacing - Whether user-added spacing already exists
-     * @returns true if spacing should be added before the current element
-     */
-    private shouldAddSpacingBetweenSiblings;
-    /**
-     * Check if we're currently processing a token list attribute that needs spacing
-     */
-    private get isInTokenListAttribute();
-    /**
-     * Render attributes as a space-separated string
-     */
-    private renderAttributesString;
-    /**
-     * Determine if a tag should be rendered inline based on attribute count and other factors
-     */
-    private shouldRenderInline;
-    private wouldClassAttributeBeMultiline;
-    private getAttributeName;
-    private getAttributeValue;
-    private hasMultilineAttributes;
-    private formatClassAttribute;
-    private isFormattableAttribute;
-    private formatMultilineAttribute;
-    private formatMultilineAttributeValue;
-    private breakTokensIntoLines;
     /**
      * Render multiline attributes for a tag
      */
@@ -138,20 +95,27 @@ export declare class FormatPrinter extends Printer {
      * Reconstruct the text representation of an ERB node
      * @param withFormatting - if true, format the content; if false, preserve original
      */
-    private reconstructERBNode;
+    reconstructERBNode(node: ERBNode, withFormatting?: boolean): string;
     /**
      * Print an ERB tag (<% %> or <%= %>) with single spaces around inner content.
      */
     printERBNode(node: ERBNode): void;
     visitDocumentNode(node: DocumentNode): void;
     visitHTMLElementNode(node: HTMLElementNode): void;
+    visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void;
+    visitHTMLConditionalOpenTagNode(node: HTMLConditionalOpenTagNode): void;
     visitHTMLElementBody(body: Node[], element: HTMLElementNode): void;
+    private visitContentPreservingBody;
+    private visitInlineElementBody;
+    private stripLeadingHerbDisable;
     /**
      * Visit element children with intelligent spacing logic
      *
      * Tracks line positions and immediately splices blank lines after rendering each child.
      */
     private visitElementChildren;
+    private visitTextFlowRunInChildren;
+    private visitChildWithTrailingHerbDisable;
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     visitHTMLCloseTagNode(node: HTMLCloseTagNode): void;
     visitHTMLTextNode(node: HTMLTextNode): void;
@@ -164,6 +128,8 @@ export declare class FormatPrinter extends Printer {
     visitXMLDeclarationNode(node: XMLDeclarationNode): void;
     visitCDATANode(node: CDATANode): void;
     visitERBContentNode(node: ERBContentNode): void;
+    visitERBOpenTagNode(node: ERBOpenTagNode): void;
+    visitHTMLVirtualCloseTagNode(_node: HTMLVirtualCloseTagNode): void;
     visitERBEndNode(node: ERBEndNode): void;
     visitERBYieldNode(node: ERBYieldNode): void;
     visitERBInNode(node: ERBInNode): void;
@@ -196,101 +162,30 @@ export declare class FormatPrinter extends Printer {
      * Determines if the close tag should be rendered inline (usually follows content decision)
      */
     private shouldRenderCloseTagInline;
+    private captureHerbDisableInline;
+    private fitsOnCurrentLine;
     private formatFrontmatter;
     /**
      * Append a child node to the last output line
      */
     private appendChildToLastLine;
-    /**
-     * Visit children in a text flow context (mixed text and inline elements)
-     * Handles word wrapping and keeps adjacent inline elements together
-     */
-    private visitTextFlowChildren;
-    /**
-     * Wrap remaining words that don't fit on the current line
-     * Returns the wrapped lines with proper indentation
-     */
-    private wrapRemainingWords;
-    /**
-     * Try to merge text starting with punctuation to inline content
-     * Returns object with merged content and whether processing should stop
-     */
-    private tryMergePunctuationText;
-    /**
-     * Render adjacent inline elements together on one line
-     */
-    private renderAdjacentInlineElements;
     /**
      * Render an inline element as a string
      */
-    private renderInlineElementAsString;
+    renderInlineElementAsString(element: HTMLElementNode): string;
     /**
      * Render an ERB node as a string
      */
-    private renderERBAsString;
+    renderERBAsString(node: ERBContentNode): string;
     /**
-     * Visit remaining children after processing adjacent inline elements
+     * Try to render an inline element, returning the full inline string or null if it can't be inlined.
      */
-    private visitRemainingChildren;
-    /**
-     * Build words array from text/inline/ERB and wrap them
-     */
-    private buildAndWrapTextFlow;
-    /**
-     * Try to merge text that follows an atomic unit (ERB/inline) with no whitespace
-     * Returns true if merge was performed
-     */
-    private tryMergeTextAfterAtomic;
-    /**
-     * Try to merge an atomic unit (ERB/inline) with preceding text that has no whitespace
-     * Returns true if merge was performed
-     */
-    private tryMergeAtomicAfterText;
-    /**
-     * Check if there's whitespace between current node and last processed node
-     */
-    private hasWhitespaceBeforeNode;
-    /**
-     * Check if last unit in result ends with whitespace
-     */
-    private lastUnitEndsWithWhitespace;
-    /**
-     * Process a text node and add it to results (with potential merging)
-     */
-    private processTextNode;
-    /**
-     * Process an inline element and add it to results (with potential merging)
-     */
-    private processInlineElement;
-    /**
-     * Process an ERB content node and add it to results (with potential merging)
-     */
-    private processERBContentNode;
-    /**
-     * Convert AST nodes to content units with node references
-     */
-    private buildContentUnitsWithNodes;
-    /**
-     * Flush accumulated words to output with wrapping
-     */
-    private flushWords;
-    /**
-     * 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;
-    private isInTextFlowContext;
+    tryRenderInlineElement(element: HTMLElementNode): string | null;
     private renderInlineOpen;
-    renderAttribute(attribute: HTMLAttributeNode): string;
     /**
      * Try to render a complete element inline including opening tag, children, and closing tag
      */
     private tryRenderInlineFull;
-    /**
-     * Check if children contain a leading herb:disable comment (after optional whitespace)
-     */
-    private hasLeadingHerbDisable;
     /**
      * Try to render just the children inline (without tags)
      */

package/dist/types/formatter.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from "@herb-tools/config";
-import type { HerbBackend } from "@herb-tools/core";
+import type { HerbBackend, ParseOptions } from "@herb-tools/core";
 import type { FormatOptions } from "./options.js";
 /**
  * Formatter uses a Herb Backend to parse the source and then
@@ -8,6 +8,7 @@ import type { FormatOptions } from "./options.js";
 export declare class Formatter {
     private herb;
     private options;
+    private parseOptions;
     /**
      * Creates a Formatter instance from a Config object (recommended).
      *
@@ -23,7 +24,7 @@ export declare class Formatter {
      * @param herb - The Herb backend instance for parsing
      * @param options - Format options (including rewriters)
      */
-    constructor(herb: HerbBackend, options?: FormatOptions);
+    constructor(herb: HerbBackend, options?: FormatOptions, parseOptions?: ParseOptions);
     /**
      * Format a source string, optionally overriding format options per call.
      */

package/dist/types/spacing-analyzer.d.ts

@@ -0,0 +1,47 @@
+import { Node, HTMLElementNode } from "@herb-tools/core";
+/**
+ * SpacingAnalyzer determines when blank lines should be inserted between
+ * sibling elements. It implements the "rule of three" intelligent spacing
+ * system: adds spacing between 3+ meaningful siblings, respects semantic
+ * groupings, groups comments with following elements, and preserves
+ * user-added spacing.
+ */
+export declare class SpacingAnalyzer {
+    private nodeIsMultiline;
+    private tagGroupsCache;
+    private allSingleLineCache;
+    constructor(nodeIsMultiline: Map<Node, boolean>);
+    clear(): void;
+    /**
+     * Determine if spacing should be added between sibling elements
+     *
+     * This implements the "rule of three" intelligent spacing system:
+     * - Adds spacing between 3 or more meaningful siblings
+     * - Respects semantic groupings (e.g., ul/li, nav/a stay tight)
+     * - Groups comments with following elements
+     * - Preserves user-added spacing
+     *
+     * @param parentElement - The parent element containing the siblings
+     * @param siblings - Array of all sibling nodes
+     * @param currentIndex - Index of the current node being evaluated
+     * @returns true if spacing should be added before the current element
+     */
+    shouldAddSpacingBetweenSiblings(parentElement: HTMLElementNode | null, siblings: Node[], currentIndex: number): boolean;
+    /**
+     * Check if there's a blank line (double newline) in the nodes at the given index
+     */
+    hasBlankLineBetween(body: Node[], index: number): boolean;
+    /**
+     * Check if a node will render as multiple lines when formatted.
+     */
+    private isMultilineElement;
+    /**
+     * Get a grouping key for a node (tag name for HTML, ERB type for ERB)
+     */
+    private getGroupingKey;
+    /**
+     * Detect groups of consecutive same-tag/same-type single-line elements
+     * Returns a map of index -> group info for efficient lookup
+     */
+    private detectTagGroups;
+}

package/dist/types/text-flow-analyzer.d.ts

@@ -0,0 +1,22 @@
+import { Node, HTMLElementNode, ERBContentNode } from "@herb-tools/core";
+import type { ContentUnitWithNode } from "./format-helpers.js";
+/**
+ * Interface that the delegate must implement to provide
+ * rendering capabilities to the TextFlowAnalyzer.
+ */
+export interface TextFlowAnalyzerDelegate {
+    tryRenderInlineElement(element: HTMLElementNode): string | null;
+    renderERBAsString(node: ERBContentNode): string;
+}
+/**
+ * TextFlowAnalyzer converts AST nodes into the ContentUnitWithNode[]
+ * intermediate representation used by the TextFlowEngine for rendering.
+ */
+export declare class TextFlowAnalyzer {
+    private delegate;
+    constructor(delegate: TextFlowAnalyzerDelegate);
+    buildContentUnits(children: Node[]): ContentUnitWithNode[];
+    private processTextNode;
+    private processInlineElement;
+    private processERBContentNode;
+}

package/dist/types/text-flow-engine.d.ts

@@ -0,0 +1,37 @@
+import { Node, HTMLElementNode } from "@herb-tools/core";
+import type { TextFlowAnalyzerDelegate } from "./text-flow-analyzer.js";
+/**
+ * Interface that the FormatPrinter implements to provide
+ * rendering capabilities to the TextFlowEngine.
+ */
+export interface TextFlowDelegate extends TextFlowAnalyzerDelegate {
+    readonly indent: string;
+    readonly maxLineLength: number;
+    push(line: string): void;
+    pushWithIndent(line: string): void;
+    renderInlineElementAsString(element: HTMLElementNode): string;
+    visit(node: Node): void;
+}
+/**
+ * TextFlowEngine handles the formatting of mixed text + inline elements + ERB content.
+ *
+ * It orchestrates analysis (via TextFlowAnalyzer) and rendering phases:
+ * groups adjacent inline elements, and wraps words to fit within line length constraints.
+ */
+export declare class TextFlowEngine {
+    private delegate;
+    private analyzer;
+    constructor(delegate: TextFlowDelegate);
+    visitTextFlowChildren(children: Node[]): void;
+    isInTextFlowContext(children: Node[]): boolean;
+    collectTextFlowRun(body: Node[], startIndex: number): {
+        nodes: Node[];
+        endIndex: number;
+    } | null;
+    isTextFlowNode(node: Node): boolean;
+    private renderAdjacentInlineElements;
+    private visitRemainingChildrenAsTextFlow;
+    private buildAndWrapTextFlow;
+    private flushWords;
+    private wrapAndPushWords;
+}

package/dist/types/text-flow-helpers.d.ts

@@ -0,0 +1,58 @@
+import { Node, HTMLTextNode } from "@herb-tools/core";
+import type { ContentUnitWithNode } from "./format-helpers.js";
+/**
+ * Check if a node participates in text flow
+ */
+export declare function isTextFlowNode(node: Node): boolean;
+/**
+ * Check if a node is whitespace that can appear within a text flow run
+ */
+export declare function isTextFlowWhitespace(node: Node): boolean;
+/**
+ * Collect a run of text flow nodes starting at the given index.
+ * Returns the nodes in the run and the index after the last node.
+ * Returns null if the run doesn't qualify (needs 2+ text flow nodes with both text and atomic content).
+ */
+export declare function collectTextFlowRun(body: Node[], startIndex: number): {
+    nodes: Node[];
+    endIndex: number;
+} | null;
+/**
+ * Check if children represent a text flow context
+ * (has text content mixed with inline elements or ERB)
+ */
+export declare function isInTextFlowContext(children: Node[]): boolean;
+/**
+ * Try to merge text that follows an atomic unit (ERB/inline) with no whitespace.
+ * Merges the first word of the text into the preceding atomic unit.
+ * Returns true if merge was performed.
+ */
+export declare function tryMergeTextAfterAtomic(result: ContentUnitWithNode[], textNode: HTMLTextNode): boolean;
+/**
+ * Try to merge an atomic unit (ERB/inline) with preceding text that has no whitespace.
+ * Splits preceding text, merges last word with atomic content.
+ * Returns true if merge was performed.
+ */
+export declare function tryMergeAtomicAfterText(result: ContentUnitWithNode[], children: Node[], lastProcessedIndex: number, atomicContent: string, atomicType: 'erb' | 'inline', atomicNode: Node): boolean;
+/**
+ * Check if there's whitespace between current node and last processed node
+ */
+export declare function hasWhitespaceBeforeNode(children: Node[], lastProcessedIndex: number, currentIndex: number, currentNode: Node): boolean;
+/**
+ * Check if last unit in result ends with whitespace
+ */
+export declare function lastUnitEndsWithWhitespace(result: ContentUnitWithNode[]): boolean;
+/**
+ * Wrap remaining words that don't fit on the current line.
+ * Returns the wrapped lines with proper indentation.
+ */
+export declare function wrapRemainingWords(words: string[], wrapWidth: number, indent: string): string[];
+/**
+ * Try to merge text starting with punctuation to inline content.
+ * Returns object with merged content and whether processing should stop.
+ */
+export declare function tryMergePunctuationText(inlineContent: string, trimmedText: string, wrapWidth: number, indent: string): {
+    mergedContent: string;
+    shouldStop: boolean;
+    wrappedLines: string[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/formatter",
-  "version": "0.8.9",
+  "version": "0.9.0",
   "description": "Auto-formatter for HTML+ERB templates with intelligent indentation, line wrapping, and ERB-aware pretty-printing.",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -35,10 +35,10 @@
     }
   },
   "dependencies": {
-    "@herb-tools/config": "0.8.9",
-    "@herb-tools/core": "0.8.9",
-    "@herb-tools/printer": "0.8.9",
-    "@herb-tools/rewriter": "0.8.9",
+    "@herb-tools/config": "0.9.0",
+    "@herb-tools/core": "0.9.0",
+    "@herb-tools/printer": "0.9.0",
+    "@herb-tools/rewriter": "0.9.0",
     "tinyglobby": "^0.2.15"
   },
   "files": [