@malloydata/malloy 0.0.385 → 0.0.387

package/dist/lang/prettify/index.js

@@ -0,0 +1,163 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * ============================================================================
+ * Malloy pretty-printer (experimental, /internal export — no stability promise)
+ * ============================================================================
+ *
+ * Architecture
+ * ------------
+ *   1. Lex + parse the input.
+ *   2. Walk the parse tree from `Formatter.format(node)`. The dispatcher routes
+ *      each rule context to a per-rule free function in a sibling module;
+ *      everything unhandled recurses to children, eventually reaching terminal
+ *      tokens that emit through `emitVisibleToken` (the leaf).
+ *   3. The leaf walker handles per-token spacing/indentation/comments. It is
+ *      v1's behaviour and is also the fallback when parsing fails.
+ *
+ * File layout
+ * -----------
+ *   - ./out                — Out buffer (indent, newlines, single-space coalescing).
+ *   - ./tokens             — LINE_BUDGET, INDENT_STR; classification sets
+ *                            (SECTION_TOKENS, BINARY_OPS, CALL_HUG_AFTER, etc.);
+ *                            findMatching, endLineOf.
+ *   - ./rules              — SECTION_STATEMENT_RULES + STATEMENT_KIND_BY_CTX.
+ *                            A maintainer adding a new section keyword lands here.
+ *   - ./error-listener     — CollectingErrorListener.
+ *   - ./types              — PrettifyError, PrettifyResult.
+ *   - ./formatter          — Formatter class (state + format() dispatcher).
+ *   - ./leaf               — emitVisibleToken + per-token state mutators
+ *                            (note, flushHiddenBefore, startStatementLine, …)
+ *                            and the small read-only helpers used by rule
+ *                            formatters (approxInlineSpan, hasCommentsInRange,
+ *                            formatTokenRange).
+ *   - ./inline-renderer    — renderItemInline (flat-string form for budget
+ *                            measurement and column alignment).
+ *   - ./block-body         — formatBlockBody, formatTopLevel.
+ *   - ./sections           — formatSectionStatement / formatSectionList.
+ *   - ./field-properties   — formatFieldProperties (postfix `{…}`).
+ *   - ./pick-case          — formatPickStatement, formatCaseStatement.
+ *   - ./binary-chain       — formatBinaryChain.
+ *   - ./index (this)       — prettify() entry point + type re-exports.
+ *
+ * Decisions worth knowing
+ * -----------------------
+ *   - Comparison operators (`=`, `!=`, `<`, `>`, …) are kept glued to their
+ *     operands. We only break chains at and/or/??/+/-. Justification: LHS/RHS
+ *     of a comparison reads as one unit; breaking inside is more confusing
+ *     than the line being long.
+ *   - SQL strings (`"""…"""`, including `%{…}` malloy interpolations) and
+ *     block annotations (`#" … "`) are emitted verbatim from source. We don't
+ *     own a SQL formatter; annotation indentation is significant.
+ *   - `;` is the compact-inline statement separator. Wrapped form drops it
+ *     (newlines do the job); inline form keeps it.
+ *   - `,` in section-list bare flow: intra-line yes, end-of-line never.
+ *   - Single-arg function calls don't wrap (no point — nowhere useful to break).
+ *   - `(` hugs only after a known-callable token (CALL_HUG_AFTER); after `is`,
+ *     `as`, `extend`, `on`, `when`, etc. the `(` is grouping and gets a space.
+ *     CALL_HUG_AFTER includes the keyword-named built-ins that are commonly
+ *     used as functions: ALL, EXCLUDE, the timeframe truncation keywords
+ *     (YEAR/MONTH/DAY/…), and the cast-target type names
+ *     (TIMESTAMP/DATE/NUMBER/STRING/BOOLEAN/JSON).
+ *   - `!` is the cast operator (`epoch_ms!timestamp(x)`); it glues to both
+ *     sides like `.` does.
+ *   - Empty `{}` collapses inline (`extend {}`, not `extend {\n}`).
+ *   - `import {a, b, c} from 'x'` formats as a flat list when it fits on the
+ *     line; otherwise one item per line at +1 indent.
+ *   - `view:` definitions in a block body always have a blank line before
+ *     each one (after the first), even when no blank was in the source. The
+ *     same-kind-no-blank rule still applies to other statement kinds.
+ *   - `{...}` bodies that contain more than one section statement never
+ *     collapse onto a single line, even when they would fit. Reading two
+ *     `group_by:` clauses jammed on one line is hostile.
+ *   - Single is-item section lists keep the keyword and item on the same
+ *     line (`nest: name is { … }`), so the body wraps naturally instead of
+ *     forcing a `nest:\n  name is {` opener split.
+ *   - join_one / join_many / join_cross multi-item lists always wrap one
+ *     item per line — items use `with`/`on` instead of `is` but are
+ *     structurally is-like.
+ *   - Trailing comments between the last item of a section list and the
+ *     enclosing `}` are emitted at the section's inner indent, so they
+ *     stay associated with the section the user wrote them in.
+ *
+ * Adding a new section-statement
+ * ------------------------------
+ *   Add a row to SECTION_STATEMENT_RULES in ./rules with the rule's context
+ *   class, the keyword token type(s), the list-context accessor, and the
+ *   item-kind tag. Add a corresponding entry to listItems() in ./sections.
+ *
+ *   Note: section keywords NOT in the table fall through to the leaf walker
+ *   (which produces correct-but-plain output). Add a row only when the default
+ *   isn't good enough — flow-fill, alignment, or annotation handling.
+ *
+ * Inter-token spacing
+ * -------------------
+ *   The classifier `leadingAction(prev, next)` in ./tokens is the single
+ *   source of truth for what separator (glue, hug, or coalescing space) goes
+ *   between two adjacent tokens. Both walkers — emitVisibleToken in ./leaf
+ *   and renderItemInline in ./inline-renderer — consult it, so a change to
+ *   `leadingAction` (e.g. adding a token type that hugs `(`) takes effect in
+ *   both paths automatically. Walker-specific concerns (newlines, indent,
+ *   paren-wrap decisions, compact-inline `, ` / `; `) live in the walker.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettify = prettify;
+const antlr4ts_1 = require("antlr4ts");
+const run_malloy_parser_1 = require("../run-malloy-parser");
+const error_listener_1 = require("./error-listener");
+const formatter_1 = require("./formatter");
+const leaf_1 = require("./leaf");
+/**
+ * Pretty-print a Malloy source string.
+ *
+ * **Experimental — this API may vanish or change at any time without notice.**
+ * It is exposed only via `@malloydata/malloy/internal` and is not covered by
+ * any compatibility commitment. Do not depend on it from anything you can't
+ * fix in a single PR.
+ *
+ * Parses the input, walks the parse tree, and emits a reformatted string.
+ *
+ * `errors` surfaces parse errors only (lexer + parser). Semantic / compile
+ * errors aren't checked here. If `errors.length > 0` you have a bigger problem
+ * than formatting — output is best-effort and not guaranteed to round-trip.
+ *
+ * @experimental
+ */
+function prettify(src) {
+    const lexerErrors = new error_listener_1.CollectingErrorListener();
+    const parserErrors = new error_listener_1.CollectingErrorListener();
+    const { tokenStream, parser: malloyParser } = (0, run_malloy_parser_1.makeMalloyParser)(src, {
+        lexerErrorListener: lexerErrors,
+        parserErrorListener: parserErrors,
+    });
+    tokenStream.fill();
+    const tokens = tokenStream.getTokens();
+    let root = null;
+    try {
+        root = malloyParser.malloyDocument();
+    }
+    catch {
+        root = null;
+    }
+    const f = new formatter_1.Formatter(src, tokens);
+    if (root) {
+        f.format(root);
+    }
+    else {
+        // Parse failed. Fall back to leaf-only emission so we still produce
+        // something reasonable.
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL && t.type !== antlr4ts_1.Token.EOF) {
+                (0, leaf_1.emitVisibleToken)(f, t, i);
+            }
+        }
+    }
+    return {
+        result: f.o.toString(),
+        errors: [...lexerErrors.errors, ...parserErrors.errors],
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/lang/prettify/inline-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { ParserRuleContext } from 'antlr4ts';
+import type { Formatter } from './formatter';
+export declare function renderItemInline(f: Formatter, ctx: ParserRuleContext): string;

package/dist/lang/prettify/inline-renderer.js

@@ -0,0 +1,101 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * renderItemInline — flat-string form of a parse-rule's token range.
+ *
+ * Used by:
+ *   - section-list inline measurement and bare-item flow-fill
+ *   - postfix `{…}` inline form
+ *   - pick / case alignment (rendering values and conditions to strings)
+ *
+ * Inter-token spacing comes from `leadingAction` in ./tokens, the same
+ * classifier the leaf walker (./leaf) consults. Both walkers therefore agree
+ * on what spacing goes between any two adjacent tokens; inline measurement
+ * predicts actual emission.
+ *
+ * Walker-specific divergence:
+ *   - This produces a flat string (no newlines, no indentation).
+ *   - SEMI emits `; ` (compact-inline form), not a newline.
+ *   - COMMA emits `, ` (intra-line form), not a newline.
+ *   - The space-coalescing skip-list omits `\n` (we never emit one) but is
+ *     otherwise the same as Out.space.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderItemInline = renderItemInline;
+const antlr4ts_1 = require("antlr4ts");
+const tokens_1 = require("./tokens");
+function renderItemInline(f, ctx) {
+    var _a;
+    let buf = '';
+    let lastType = null;
+    // Coalescing space: skip if buffer is empty or last char already provides
+    // separation. Mirrors Out.space() (./out) minus the newline check, since
+    // this renderer never emits a newline.
+    const space = () => {
+        if (buf.length === 0)
+            return;
+        const last = buf[buf.length - 1];
+        if (last === ' ' || last === '(' || last === '[' || last === '.')
+            return;
+        buf += ' ';
+    };
+    const trim = () => {
+        buf = buf.replace(/ +$/, '');
+    };
+    for (let i = ctx._start.tokenIndex; i <= ctx._stop.tokenIndex; i++) {
+        const t = f.tokens[i];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+        if (t.type === tokens_1.L.SQL_BEGIN) {
+            const endIdx = (0, tokens_1.findMatching)(f.tokens, i, tokens_1.L.SQL_BEGIN, tokens_1.L.SQL_END);
+            const stop = f.tokens[endIdx].stopIndex;
+            space();
+            buf += f.src.substring(t.startIndex, stop + 1);
+            i = endIdx;
+            lastType = tokens_1.L.SQL_END;
+            continue;
+        }
+        if (t.type === tokens_1.L.CCURLY) {
+            // `{}` empty: no inner space. `{ x }`: both inner spaces.
+            if (buf.length > 0 && !buf.endsWith('{') && !buf.endsWith(' '))
+                buf += ' ';
+            else
+                trim();
+            buf += '}';
+            lastType = t.type;
+            continue;
+        }
+        // Walker-specific divergence: COMMA and SEMI use compact-inline form
+        // (`, ` and `; `). The leaf walker (./leaf) emits newlines for these in
+        // wrapped contexts.
+        if (t.type === tokens_1.L.COMMA) {
+            trim();
+            buf += ', ';
+            lastType = t.type;
+            continue;
+        }
+        if (t.type === tokens_1.L.SEMI) {
+            trim();
+            buf += '; ';
+            lastType = t.type;
+            continue;
+        }
+        // Everything else: classifier-driven leading separator + text + (if a
+        // binary op) trailing space. Same shape as the leaf walker's default.
+        const action = (0, tokens_1.leadingAction)(lastType, t.type);
+        if (action === 'glue')
+            trim();
+        else if (action === 'space')
+            space();
+        // 'hug' — emit nothing before
+        buf += text;
+        if (tokens_1.BINARY_OPS.has(t.type))
+            buf += ' ';
+        lastType = t.type;
+    }
+    return buf;
+}
+//# sourceMappingURL=inline-renderer.js.map

package/dist/lang/prettify/leaf.d.ts

@@ -0,0 +1,9 @@
+import { Token } from 'antlr4ts';
+import type { Formatter } from './formatter';
+export declare function note(f: Formatter, tokenType: number, idx: number, endTok: Token): void;
+export declare function flushHiddenBefore(f: Formatter, idx: number): void;
+export declare function startStatementLine(f: Formatter): void;
+export declare function approxInlineSpan(f: Formatter, fromIdx: number, toIdx: number): number;
+export declare function hasCommentsInRange(f: Formatter, fromIdx: number, toIdx: number): boolean;
+export declare function emitVisibleToken(f: Formatter, t: Token, idx: number): void;
+export declare function formatTokenRange(f: Formatter, fromIdx: number, toIdx: number): void;

package/dist/lang/prettify/leaf.js

@@ -0,0 +1,340 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Leaf walker: per-token spacing, structural punctuation, comment placement,
+ * and the small helpers the rule formatters use to look at adjacent tokens.
+ *
+ * Per-rule formatters call into here via:
+ *   - emitVisibleToken         — the leaf
+ *   - flushHiddenBefore        — emit pending comments before a target index
+ *   - note                     — atomic per-token state update
+ *   - startStatementLine       — newline (consuming `needBlank`) for stmt start
+ *   - approxInlineSpan         — line-budget overestimate for a token range
+ *   - hasCommentsInRange       — comment-presence check (gates inline form)
+ *   - formatTokenRange         — emit a span via the leaf walker
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.note = note;
+exports.flushHiddenBefore = flushHiddenBefore;
+exports.startStatementLine = startStatementLine;
+exports.approxInlineSpan = approxInlineSpan;
+exports.hasCommentsInRange = hasCommentsInRange;
+exports.emitVisibleToken = emitVisibleToken;
+exports.formatTokenRange = formatTokenRange;
+const antlr4ts_1 = require("antlr4ts");
+const tokens_1 = require("./tokens");
+// Update per-token state after emitting a token (or a token-like span).
+function note(f, tokenType, idx, endTok) {
+    f.lastEmittedType = tokenType;
+    f.prevTokenEndLine = (0, tokens_1.endLineOf)(endTok);
+    f.lastEmittedIdx = idx;
+}
+// Emit any hidden-channel tokens (comments) sitting between f.lastEmittedIdx
+// and idx-1, advancing f.lastEmittedIdx so they are not re-emitted by a later
+// call. Visible tokens in the same range (e.g. commas the section-list rule
+// chose to drop) are skipped.
+function flushHiddenBefore(f, idx) {
+    if (idx <= f.lastEmittedIdx + 1)
+        return;
+    for (let j = f.lastEmittedIdx + 1; j < idx; j++) {
+        const t = f.tokens[j];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL) {
+            emitHiddenToken(f, t);
+        }
+    }
+    f.lastEmittedIdx = idx - 1;
+}
+// Hidden-channel tokens (comments). Trailing comments (same line as previous
+// token) attach with a space; leading comments (own line) start a fresh line.
+function emitHiddenToken(f, t) {
+    var _a;
+    const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+    const sameLine = f.prevTokenEndLine !== 0 && t.line === f.prevTokenEndLine;
+    if (t.type === tokens_1.L.COMMENT_TO_EOL) {
+        if (sameLine) {
+            f.o.space();
+            f.o.text(text.replace(/\s+$/, ''));
+            f.o.nl();
+        }
+        else {
+            if (f.o.indent === 0)
+                startStatementLine(f);
+            else
+                f.o.nl();
+            f.o.text(text.replace(/\s+$/, ''));
+            f.o.nl();
+        }
+    }
+    else if (t.type === tokens_1.L.BLOCK_COMMENT) {
+        if (sameLine) {
+            f.o.space();
+            f.o.text(text);
+            f.o.space();
+        }
+        else {
+            if (f.o.indent === 0)
+                startStatementLine(f);
+            else
+                f.o.nl();
+            f.o.text(text);
+            f.o.nl();
+        }
+    }
+    f.prevTokenEndLine = (0, tokens_1.endLineOf)(t);
+}
+// Either consume `needBlank` (emit blank line) or just newline.
+function startStatementLine(f) {
+    if (f.needBlank) {
+        f.o.blank();
+        f.needBlank = false;
+    }
+    else {
+        f.o.nl();
+    }
+}
+// Approximate length of the inline form of tokens [fromIdx, toIdx]: sum of
+// visible token text + 1 char between adjacent tokens. Used for budget checks
+// (paren wrap, pickStatement wrap, etc.). It's an overestimate for dotted-paths
+// and similar (`a.b` is 3 chars, our estimate is 5) but the direction is
+// conservative — we wrap a touch sooner than strictly needed.
+function approxInlineSpan(f, fromIdx, toIdx) {
+    var _a;
+    let len = 0;
+    let prev = -1;
+    for (let i = fromIdx; i <= toIdx; i++) {
+        const t = f.tokens[i];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === antlr4ts_1.Token.EOF)
+            continue;
+        if (prev >= 0)
+            len += 1;
+        len += ((_a = t.text) !== null && _a !== void 0 ? _a : '').length;
+        prev = i;
+    }
+    return len;
+}
+// Are there any hidden-channel tokens (comments) in [fromIdx, toIdx]? Used to
+// gate inline-form candidates: any path that goes through `renderItemInline`
+// strips comments, so candidates with comments must fall back to wrapped or
+// broken form where the leaf walker preserves them.
+function hasCommentsInRange(f, fromIdx, toIdx) {
+    for (let i = fromIdx; i <= toIdx; i++) {
+        if (f.tokens[i].channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            return true;
+    }
+    return false;
+}
+// Index of the next non-hidden, non-EOF token strictly after `idx`, or -1.
+function nextVisibleAfter(f, idx) {
+    for (let j = idx + 1; j < f.tokens.length; j++) {
+        const t = f.tokens[j];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === antlr4ts_1.Token.EOF)
+            return -1;
+        return j;
+    }
+    return -1;
+}
+// Does the paren-pair at [openIdx, closeIdx] have any COMMA at its own depth?
+// (Used to distinguish "function call with multiple args" from "single-arg
+// call" / "empty parens".)
+function hasCommaAtDepth1(f, openIdx, closeIdx) {
+    let depth = 0;
+    for (let i = openIdx + 1; i < closeIdx; i++) {
+        const t = f.tokens[i];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK || t.type === tokens_1.L.OCURLY)
+            depth++;
+        else if (t.type === tokens_1.L.CPAREN || t.type === tokens_1.L.CBRACK || t.type === tokens_1.L.CCURLY)
+            depth--;
+        else if (t.type === tokens_1.L.COMMA && depth === 0)
+            return true;
+    }
+    return false;
+}
+// The big switch. Each branch ends with `note(...)`.
+function emitVisibleToken(f, t, idx) {
+    var _a, _b;
+    if (idx <= f.lastEmittedIdx)
+        return; // already emitted (e.g. SQL block range)
+    flushHiddenBefore(f, idx);
+    const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+    // ---- Verbatim regions: SQL strings and block annotations ----
+    // We don't own a SQL formatter. Annotation indentation is significant.
+    if (t.type === tokens_1.L.SQL_BEGIN) {
+        const endIdx = (0, tokens_1.findMatching)(f.tokens, idx, tokens_1.L.SQL_BEGIN, tokens_1.L.SQL_END);
+        const stop = f.tokens[endIdx].stopIndex;
+        f.o.space();
+        f.o.text(f.src.substring(t.startIndex, stop + 1));
+        note(f, tokens_1.L.SQL_END, endIdx, f.tokens[endIdx]);
+        return;
+    }
+    if (t.type === tokens_1.L.BLOCK_ANNOTATION_BEGIN ||
+        t.type === tokens_1.L.DOC_BLOCK_ANNOTATION_BEGIN) {
+        const endIdx = (0, tokens_1.findMatching)(f.tokens, idx, t.type, tokens_1.L.BLOCK_ANNOTATION_END);
+        const stop = f.tokens[endIdx].stopIndex;
+        if (f.o.indent === 0)
+            startStatementLine(f);
+        else
+            f.o.nl();
+        f.o.text(f.src.substring(t.startIndex, stop + 1));
+        f.o.nl();
+        note(f, tokens_1.L.BLOCK_ANNOTATION_END, endIdx, f.tokens[endIdx]);
+        return;
+    }
+    // ---- Single-line annotations on their own line ----
+    if (t.type === tokens_1.L.ANNOTATION || t.type === tokens_1.L.DOC_ANNOTATION) {
+        if (f.o.indent === 0)
+            startStatementLine(f);
+        else
+            f.o.nl();
+        f.o.text(text.replace(/\s+$/, ''));
+        f.o.nl();
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Curly braces: indent in/out around block bodies ----
+    if (t.type === tokens_1.L.OCURLY) {
+        f.o.space();
+        f.o.text('{');
+        // Empty `{}`: peek the next visible token. If it's the matching close
+        // AND nothing hidden sits between them (no comments to preserve), emit
+        // inline so we get `extend {}` not `extend {\n}`. With a comment in the
+        // gap (`extend { /* keep */ }`), fall through to the wrapping form so
+        // the leaf walker's comment placement runs.
+        const nextVisible = nextVisibleAfter(f, idx);
+        if (nextVisible !== -1 &&
+            f.tokens[nextVisible].type === tokens_1.L.CCURLY &&
+            !hasCommentsInRange(f, idx + 1, nextVisible - 1)) {
+            f.o.text('}');
+            if (f.o.indent === 0)
+                f.needBlank = true;
+            note(f, tokens_1.L.CCURLY, nextVisible, f.tokens[nextVisible]);
+            return;
+        }
+        f.o.indent++;
+        f.o.nl();
+        note(f, t.type, idx, t);
+        return;
+    }
+    if (t.type === tokens_1.L.CCURLY) {
+        f.o.indent = Math.max(0, f.o.indent - 1);
+        f.o.nl();
+        f.o.text('}');
+        if (f.o.indent === 0)
+            f.needBlank = true;
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Statement separators ----
+    // `;` in wrapped form is dropped — newlines do the job. (Inline `;` appears
+    // via renderItemInline, not here.)
+    if (t.type === tokens_1.L.SEMI) {
+        f.o.trimTrailingSpace();
+        f.o.nl();
+        if (f.o.indent === 0)
+            f.needBlank = true;
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Commas ----
+    // At top level (parenDepth==0) → newline. Inside parens that the wrap logic
+    // flagged as multi-line → newline. Otherwise inline (just space).
+    if (t.type === tokens_1.L.COMMA) {
+        f.o.trimTrailingSpace();
+        f.o.text(',');
+        const innerBreaks = f.parenBreaks.length > 0 && f.parenBreaks[f.parenBreaks.length - 1];
+        if (f.parenDepth === 0 || innerBreaks)
+            f.o.nl();
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Open paren / bracket: decide call-hug vs grouping, decide wrap ----
+    if (t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK) {
+        const action = (0, tokens_1.leadingAction)(f.lastEmittedType, t.type);
+        if (action === 'space')
+            f.o.space();
+        f.o.text(text);
+        // Decide whether the contents will exceed the line budget when laid out
+        // inline. Break only if there's somewhere useful to break:
+        //   - call/subscript parens (action='hug'): must have ≥ 2 args (commas at
+        //     this depth);
+        //   - grouping parens (action='space'): any overflow — content's own
+        //     rules will wrap.
+        const closeType = t.type === tokens_1.L.OPAREN ? tokens_1.L.CPAREN : tokens_1.L.CBRACK;
+        const matchIdx = (0, tokens_1.findMatching)(f.tokens, idx, t.type, closeType);
+        const inlineLen = approxInlineSpan(f, idx, matchIdx);
+        const wouldOverflow = f.o.lineLengthSoFar() + inlineLen > tokens_1.LINE_BUDGET;
+        const hasArgCommas = hasCommaAtDepth1(f, idx, matchIdx);
+        const isCall = action === 'hug';
+        const willBreak = wouldOverflow && (hasArgCommas || !isCall);
+        f.parenBreaks.push(willBreak);
+        f.parenDepth++;
+        if (willBreak) {
+            f.o.indent++;
+            f.o.nl();
+        }
+        note(f, t.type, idx, t);
+        return;
+    }
+    if (t.type === tokens_1.L.CPAREN || t.type === tokens_1.L.CBRACK) {
+        const wasBreak = (_b = f.parenBreaks.pop()) !== null && _b !== void 0 ? _b : false;
+        if (wasBreak) {
+            f.o.indent = Math.max(0, f.o.indent - 1);
+            f.o.nl();
+        }
+        else {
+            f.o.trimTrailingSpace();
+        }
+        f.o.text(text);
+        f.parenDepth = Math.max(0, f.parenDepth - 1);
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Section keyword fallback (no explicit handler took it) ----
+    // Inside a brace block, force a fresh line. Keeps v1-style readable output
+    // even for sections we don't yet handle.
+    if (tokens_1.SECTION_TOKENS.has(t.type) && f.o.indent > 0) {
+        f.o.nl();
+        f.o.text(text.replace(/\s+/g, ''));
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Top-level statement starter ----
+    if (tokens_1.TOP_LEVEL_STARTERS.has(t.type) &&
+        f.o.indent === 0 &&
+        f.parenDepth === 0) {
+        startStatementLine(f);
+        f.o.text(text.replace(/\s+/g, ''));
+        note(f, t.type, idx, t);
+        return;
+    }
+    // ---- Default: identifier / literal / keyword / DOT / COLON / TRIPLECOLON
+    //      / binary op. Leading separator from the classifier; binary ops also
+    //      get a trailing space.
+    const action = (0, tokens_1.leadingAction)(f.lastEmittedType, t.type);
+    if (action === 'glue')
+        f.o.trimTrailingSpace();
+    else if (action === 'space')
+        f.o.space();
+    // 'hug' — emit nothing before
+    f.o.text(text);
+    if (tokens_1.BINARY_OPS.has(t.type))
+        f.o.space();
+    note(f, t.type, idx, t);
+}
+// Emit each visible token in [fromIdx, toIdx] via the leaf walker.
+function formatTokenRange(f, fromIdx, toIdx) {
+    for (let i = fromIdx; i <= toIdx; i++) {
+        const t = f.tokens[i];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL && t.type !== antlr4ts_1.Token.EOF) {
+            emitVisibleToken(f, t, i);
+        }
+    }
+}
+//# sourceMappingURL=leaf.js.map

package/dist/lang/prettify/out.d.ts

@@ -0,0 +1,12 @@
+export declare class Out {
+    buf: string;
+    indent: number;
+    text(s: string): void;
+    space(): void;
+    nl(): void;
+    blank(): void;
+    trimTrailingSpace(): void;
+    trimTrailingNewlines(): void;
+    lineLengthSoFar(): number;
+    toString(): string;
+}