@malloydata/malloy 0.0.385 → 0.0.387

package/dist/lang/prettify/sections.js

@@ -0,0 +1,380 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: SECTION-STATEMENT — formatSectionStatement / formatSectionList
+ *
+ * A `keyword: items` block. The statement context wraps:
+ *   <tags?> <ACCESS_LABEL?> <KEYWORD> <listCtx>
+ * We walk children: tags + access-label go through the normal dispatcher
+ * (so annotations are preserved); the KEYWORD is emitted manually; the
+ * list context dispatches to formatSectionList.
+ *
+ * formatSectionList rule (locked in with the user):
+ *   - All bare items + total fits ≤ LINE_BUDGET → inline `kw: a, b, c`.
+ *   - Single item that fits (even if it has `is`) → inline. Items containing
+ *     a `{...}` body with more than one section statement are excluded —
+ *     view bodies don't read on one line regardless of length.
+ *   - Single is-item that doesn't fit inline → keep keyword and item on the
+ *     same line (`nest: name is { …wrapped body… }`); the body's `{...}`
+ *     wraps internally. Annotated items still take the keyword-on-own-line
+ *     form so the annotation lands above its item.
+ *   - Otherwise → wrapped: keyword on its own line; items at +1 indent;
+ *       bare items flow-fill ≤ LINE_BUDGET, comma-separated intra-line,
+ *       no trailing commas; `is` items each on own line; annotated items
+ *       each on own line, annotation on the line above.
+ *
+ * After the last item, trailing comments that sit between the section and
+ * the enclosing `}` are also emitted at the inner indent — they belong to
+ * the section the user just wrote, not the parent block.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSectionStatement = formatSectionStatement;
+const antlr4ts_1 = require("antlr4ts");
+const tree_1 = require("antlr4ts/tree");
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatSectionStatement(f, stmt, rule) {
+    var _a;
+    const keywordTok = findKeyword(stmt, rule.keywordTypes);
+    const listCtx = rule.list(stmt);
+    if (!keywordTok || !listCtx) {
+        (0, leaf_1.formatTokenRange)(f, stmt._start.tokenIndex, stmt._stop.tokenIndex);
+        return;
+    }
+    for (let i = 0; i < stmt.childCount; i++) {
+        const c = stmt.getChild(i);
+        const isKeywordChild = (c instanceof tree_1.TerminalNode && c.symbol === keywordTok) ||
+            (c instanceof antlr4ts_1.ParserRuleContext && childContainsToken(c, keywordTok));
+        if (isKeywordChild) {
+            (0, leaf_1.flushHiddenBefore)(f, keywordTok.tokenIndex);
+            if (f.o.indent > 0)
+                f.o.nl();
+            else
+                (0, leaf_1.startStatementLine)(f);
+            f.o.text(((_a = keywordTok.text) !== null && _a !== void 0 ? _a : '').replace(/\s+/g, ''));
+            (0, leaf_1.note)(f, keywordTok.type, keywordTok.tokenIndex, keywordTok);
+            continue;
+        }
+        if (c === listCtx) {
+            const items = listItems(listCtx, rule.itemKind);
+            if (items.length > 0)
+                formatSectionList(f, items, rule.itemKind);
+            continue;
+        }
+        f.format(c);
+    }
+}
+function childContainsToken(node, tok) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof tree_1.TerminalNode && c.symbol === tok)
+            return true;
+    }
+    return false;
+}
+function findKeyword(node, types) {
+    // Direct terminal children — fast path, the common case.
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof tree_1.TerminalNode && types.includes(c.symbol.type))
+            return c.symbol;
+    }
+    // Fallback: descend one level. Some rules wrap the keyword in a small
+    // nested rule (e.g. includeItem → accessLabelProp → INTERNAL).
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof antlr4ts_1.ParserRuleContext) {
+            for (let j = 0; j < c.childCount; j++) {
+                const g = c.getChild(j);
+                if (g instanceof tree_1.TerminalNode && types.includes(g.symbol.type))
+                    return g.symbol;
+            }
+        }
+    }
+    return undefined;
+}
+function listItems(listCtx, itemKind) {
+    // Type predicate (`c is ParserRuleContext`) so callers don't need a cast.
+    const matches = (c) => {
+        if (!(c instanceof antlr4ts_1.ParserRuleContext))
+            return false;
+        switch (itemKind) {
+            case 'fieldEntry':
+                return c instanceof parser.QueryFieldEntryContext;
+            case 'nestEntry':
+                return c instanceof parser.NestEntryContext;
+            case 'fieldDef':
+                return c instanceof parser.FieldDefContext;
+            case 'fieldName':
+                return c instanceof parser.FieldNameContext;
+            case 'collectionMember':
+                return c instanceof parser.CollectionMemberContext;
+            case 'orderBySpec':
+                return c instanceof parser.OrderBySpecContext;
+            case 'fieldExpr':
+                return c instanceof parser.FieldExprContext;
+            case 'joinDef':
+                return c instanceof parser.JoinDefContext;
+            case 'includeField':
+                return c instanceof parser.IncludeFieldContext;
+            case 'indexElement':
+                return c instanceof parser.IndexElementContext;
+        }
+    };
+    const out = [];
+    for (let i = 0; i < listCtx.childCount; i++) {
+        const c = listCtx.getChild(i);
+        if (matches(c))
+            out.push(c);
+    }
+    return out;
+}
+function classifyItem(f, ctx, itemKind) {
+    // joinDef items always wrap onto their own line. They use `with` / `on`
+    // instead of `is`, but they're structurally one-per-line like is-items.
+    let hasIs = itemKind === 'joinDef';
+    let hasAnnotation = false;
+    for (let i = ctx._start.tokenIndex; i <= ctx._stop.tokenIndex; i++) {
+        const t = f.tokens[i];
+        if (t.type === tokens_1.L.IS)
+            hasIs = true;
+        if (t.type === tokens_1.L.ANNOTATION ||
+            t.type === tokens_1.L.DOC_ANNOTATION ||
+            t.type === tokens_1.L.BLOCK_ANNOTATION_BEGIN ||
+            t.type === tokens_1.L.DOC_BLOCK_ANNOTATION_BEGIN)
+            hasAnnotation = true;
+    }
+    return { ctx, hasIs, hasAnnotation };
+}
+function formatSectionList(f, items, itemKind) {
+    const itemInfos = items.map(it => classifyItem(f, it, itemKind));
+    const noAnnotations = itemInfos.every(info => !info.hasAnnotation);
+    const allBare = itemInfos.every(info => !info.hasIs && !info.hasAnnotation);
+    const firstItem = items[0];
+    const lastItem = items[items.length - 1];
+    // Inline candidate: no annotations, no hidden-channel comments anywhere in
+    // the items' span (renderItemInline drops them), AND either all bare or
+    // exactly one item. Items containing a `{...}` body with multiple inner
+    // statements are also excluded — collapsing a view body onto one line is
+    // hostile to read regardless of length.
+    const itemsHaveComments = (0, leaf_1.hasCommentsInRange)(f, firstItem._start.tokenIndex, lastItem._stop.tokenIndex);
+    const itemsHaveMultiStatementBody = itemInfos.some(info => hasMultiStatementCurlyBody(f, info.ctx));
+    const inlineEligible = noAnnotations &&
+        !itemsHaveComments &&
+        !itemsHaveMultiStatementBody &&
+        (allBare || items.length === 1);
+    if (inlineEligible) {
+        const renderedItems = itemInfos.map(info => (0, inline_renderer_1.renderItemInline)(f, info.ctx));
+        const inlineBody = renderedItems.join(', ');
+        const candidateLen = f.o.lineLengthSoFar() + 1 /* space */ + inlineBody.length;
+        if (candidateLen <= tokens_1.LINE_BUDGET) {
+            f.o.text(' ');
+            f.o.text(inlineBody);
+            (0, leaf_1.note)(f, lastItem._stop.type, lastItem._stop.tokenIndex, lastItem._stop);
+            return;
+        }
+    }
+    // Single is-item that doesn't fit inline: keep the keyword on the same
+    // line as the item (`nest: name is { …wrapped body… }`) instead of
+    // breaking before the name. The body's `{...}` will wrap on its own.
+    // Annotated items still need the keyword-on-own-line form so the
+    // annotation can land between them.
+    if (items.length === 1 &&
+        itemInfos[0].hasIs &&
+        !itemInfos[0].hasAnnotation &&
+        !itemsHaveComments) {
+        f.o.text(' ');
+        f.format(itemInfos[0].ctx);
+        f.lastEmittedType = lastItem._stop.type;
+        return;
+    }
+    // Wrapped form. Two paths:
+    //   - No comments anywhere: original flow-fill — bare items pack into lines
+    //     at LINE_BUDGET, `is`/annotated items each get their own line.
+    //   - Comments anywhere in the items' span: every item emits on its own
+    //     line via f.format(), which goes through emitVisibleToken /
+    //     flushHiddenBefore and handles trailing-vs-leading attachment for
+    //     hidden-channel tokens correctly. Flow-fill density is sacrificed for
+    //     comment correctness.
+    f.o.indent++;
+    f.o.nl();
+    if (itemsHaveComments) {
+        f.lastEmittedIdx = firstItem._start.tokenIndex - 1;
+        for (let k = 0; k < itemInfos.length; k++) {
+            const info = itemInfos[k];
+            // flushHiddenBefore handles between-item comments and advances
+            // lastEmittedIdx so they aren't re-emitted by f.format(item)'s own first
+            // emit.
+            (0, leaf_1.flushHiddenBefore)(f, info.ctx._start.tokenIndex);
+            f.o.nl();
+            f.format(info.ctx);
+        }
+        flushSameLineTail(f, lastItem._stop);
+        f.o.indent--;
+        // Update lastEmittedType for leading-action decisions, but DO NOT reset
+        // lastEmittedIdx — flushSameLineTail may have advanced it past tail
+        // comments, and rolling it back would let the parent re-emit them.
+        f.lastEmittedType = lastItem._stop.type;
+        return;
+    }
+    // No-comments fast path: flow-fill packing as before.
+    let curBare = '';
+    const flushBare = () => {
+        if (curBare.length > 0) {
+            f.o.text(curBare);
+            f.o.nl();
+            curBare = '';
+        }
+    };
+    for (const info of itemInfos) {
+        if (info.hasIs || info.hasAnnotation) {
+            flushBare();
+            (0, leaf_1.flushHiddenBefore)(f, info.ctx._start.tokenIndex);
+            f.format(info.ctx);
+            f.o.nl();
+        }
+        else {
+            const itemText = (0, inline_renderer_1.renderItemInline)(f, info.ctx);
+            const indentChars = f.o.indent * tokens_1.INDENT_STR.length;
+            const sepLen = curBare.length > 0 ? 2 : 0; // ", "
+            const projected = indentChars + curBare.length + sepLen + itemText.length;
+            if (curBare.length > 0 && projected > tokens_1.LINE_BUDGET) {
+                flushBare();
+                curBare = itemText;
+            }
+            else {
+                curBare = curBare.length > 0 ? curBare + ', ' + itemText : itemText;
+            }
+        }
+    }
+    flushBare();
+    flushSameLineTail(f, lastItem._stop);
+    f.o.indent--;
+    // See comment in the with-comments branch: keep the advanced
+    // lastEmittedIdx so tail comments aren't re-emitted by the parent.
+    f.lastEmittedType = lastItem._stop.type;
+}
+// Does any `{...}` block inside this item contain more than one section
+// keyword (group_by:, aggregate:, where:, …) at its top level? Used to gate
+// the section-list inline form: a view body with multiple statements never
+// reads well on a single line, even when it fits. Single-statement bodies
+// like `{ where: x = 1 }` may still inline.
+function hasMultiStatementCurlyBody(f, ctx) {
+    const fromIdx = ctx._start.tokenIndex;
+    const toIdx = ctx._stop.tokenIndex;
+    for (let i = fromIdx; i <= toIdx; i++) {
+        if (f.tokens[i].type !== tokens_1.L.OCURLY)
+            continue;
+        const close = (0, tokens_1.findMatching)(f.tokens, i, tokens_1.L.OCURLY, tokens_1.L.CCURLY);
+        let count = 0;
+        let depth = 0;
+        for (let j = i + 1; j < close; j++) {
+            const t = f.tokens[j];
+            if (t.type === tokens_1.L.OCURLY || t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK) {
+                depth++;
+            }
+            else if (t.type === tokens_1.L.CCURLY ||
+                t.type === tokens_1.L.CPAREN ||
+                t.type === tokens_1.L.CBRACK) {
+                depth--;
+            }
+            else if (depth === 0 && tokens_1.SECTION_TOKENS.has(t.type)) {
+                count++;
+                if (count > 1)
+                    return true;
+            }
+        }
+        i = close;
+    }
+    return false;
+}
+// After the last item of a wrapped section list, flush trailing comments
+// belonging to the section. There are two cases:
+//
+//   1. Same-line tail: a comment on the SAME source line as the last item.
+//      Always belongs to the last item; emit at the section's inner indent.
+//
+//   2. Different-line trailing comments that sit between the last item and
+//      the closing `}` of the enclosing block (no other statement follows).
+//      These visually belong to the section the user just wrote, not the
+//      block. Emit them at the inner indent so they stay associated with
+//      the section. If a real statement follows the comments, leave them
+//      for the parent — they're leading comments for that statement.
+function flushSameLineTail(f, lastTok) {
+    const lastEndLine = (0, tokens_1.endLineOf)(lastTok);
+    let j = lastTok.tokenIndex + 1;
+    // Phase 1: same-line tail comments.
+    while (j < f.tokens.length) {
+        const t = f.tokens[j];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
+            break;
+        if (t.line !== lastEndLine)
+            break;
+        j++;
+    }
+    if (j > lastTok.tokenIndex + 1) {
+        // Same-line comments: drop the wrapping loop's per-item newline so
+        // emitHiddenToken's same-line branch reattaches the comment correctly
+        // (and adds a trailing newline back for EOL comments). Otherwise a
+        // re-parse sees a different-line comment, breaking idempotence.
+        f.o.trimTrailingNewlines();
+        (0, leaf_1.flushHiddenBefore)(f, j);
+    }
+    // Phase 2: own-line comments before the next visible token. If the next
+    // visible token is a closing `}`, the comments visually belong to this
+    // section — emit them at the inner indent. Otherwise leave them for the
+    // parent (they're leading comments for whatever follows).
+    let k = j;
+    let trailingHidden = 0;
+    while (k < f.tokens.length) {
+        const t = f.tokens[k];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
+            break;
+        trailingHidden++;
+        k++;
+    }
+    if (trailingHidden > 0 && k < f.tokens.length) {
+        const next = f.tokens[k];
+        if (next.type === tokens_1.L.CCURLY) {
+            (0, leaf_1.flushHiddenBefore)(f, k);
+        }
+    }
+}
+//# sourceMappingURL=sections.js.map

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

@@ -0,0 +1,13 @@
+import type { Token } from 'antlr4ts';
+import { MalloyLexer } from '../lib/Malloy/MalloyLexer';
+export declare const L: typeof MalloyLexer;
+export declare const LINE_BUDGET = 100;
+export declare const INDENT_STR = "  ";
+export declare const SECTION_TOKENS: Set<number>;
+export declare const TOP_LEVEL_STARTERS: Set<number>;
+export declare const CALL_HUG_AFTER: Set<number>;
+export declare const BINARY_OPS: Set<number>;
+export type LeadingAction = 'glue' | 'hug' | 'space';
+export declare function leadingAction(prevType: number | null, nextType: number): LeadingAction;
+export declare function endLineOf(t: Token): number;
+export declare function findMatching(tokens: Token[], startIdx: number, beginType: number, endType: number): number;

package/dist/lang/prettify/tokens.js

@@ -0,0 +1,185 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Token classification, layout config, and small token utilities used by the
+ * prettifier's leaf walker and rule formatters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BINARY_OPS = exports.CALL_HUG_AFTER = exports.TOP_LEVEL_STARTERS = exports.SECTION_TOKENS = exports.INDENT_STR = exports.LINE_BUDGET = exports.L = void 0;
+exports.leadingAction = leadingAction;
+exports.endLineOf = endLineOf;
+exports.findMatching = findMatching;
+const MalloyLexer_1 = require("../lib/Malloy/MalloyLexer");
+exports.L = MalloyLexer_1.MalloyLexer;
+// ---------- Global formatting config ----------
+exports.LINE_BUDGET = 100;
+exports.INDENT_STR = '  '; // two spaces per indent level
+// ---------- Token classification ----------
+// Section keywords that introduce a `keyword: items` block (or a single value
+// for some). Used by the leaf walker as a fallback newline rule when no
+// explicit section-statement handler caught us.
+exports.SECTION_TOKENS = new Set([
+    exports.L.ACCEPT,
+    exports.L.AGGREGATE,
+    exports.L.CALCULATE,
+    exports.L.CALCULATION,
+    exports.L.CONNECTION,
+    exports.L.DECLARE,
+    exports.L.DIMENSION,
+    exports.L.DRILL,
+    exports.L.EXCEPT,
+    exports.L.EXTENDQ,
+    exports.L.GROUP_BY,
+    exports.L.GROUPED_BY,
+    exports.L.HAVING,
+    exports.L.INDEX,
+    exports.L.INTERNAL,
+    exports.L.JOIN_CROSS,
+    exports.L.JOIN_ONE,
+    exports.L.JOIN_MANY,
+    exports.L.LIMIT,
+    exports.L.MEASURE,
+    exports.L.NEST,
+    exports.L.ORDER_BY,
+    exports.L.PARTITION_BY,
+    exports.L.PRIMARY_KEY,
+    exports.L.PRIVATE,
+    exports.L.PROJECT,
+    exports.L.PUBLIC,
+    exports.L.QUERY,
+    exports.L.RENAME,
+    exports.L.RUN,
+    exports.L.SAMPLE,
+    exports.L.SELECT,
+    exports.L.SOURCE,
+    exports.L.TYPE,
+    exports.L.TOP,
+    exports.L.WHERE,
+    exports.L.VIEW,
+    exports.L.TIMEZONE,
+]);
+// Top-level statement starters. At column 0 each gets a blank line before it
+// when introducing a new statement (subject to the same-kind-no-blank rule).
+exports.TOP_LEVEL_STARTERS = new Set([
+    exports.L.SOURCE,
+    exports.L.QUERY,
+    exports.L.RUN,
+    exports.L.IMPORT,
+]);
+// Token types after which an immediately following `(` or `[` is a call /
+// subscript and should hug (no leading space). Anything else (binary ops,
+// IS/AS/EXTEND/ON/WHEN/PICK/etc.) gets a space — the `(` is grouping.
+exports.CALL_HUG_AFTER = new Set([
+    exports.L.IDENTIFIER,
+    exports.L.CPAREN,
+    exports.L.CBRACK,
+    // Aggregate / built-in callable keywords commonly used as function names.
+    exports.L.COUNT,
+    exports.L.SUM,
+    exports.L.AVG,
+    exports.L.MIN,
+    exports.L.MAX,
+    exports.L.TABLE,
+    exports.L.SQL,
+    exports.L.COMPOSE,
+    exports.L.CAST,
+    exports.L.NOW,
+    exports.L.LAST,
+    // Ungrouped / level-modifier function-style calls.
+    exports.L.ALL,
+    exports.L.EXCLUDE,
+    // Timeframe truncation keywords used as functions: year(x), month(x), …
+    exports.L.YEAR,
+    exports.L.QUARTER,
+    exports.L.MONTH,
+    exports.L.WEEK,
+    exports.L.DAY,
+    exports.L.HOUR,
+    exports.L.MINUTE,
+    exports.L.SECOND,
+    // Type-cast keyword names: timestamp(x), date(x), number(x), string(x), …
+    exports.L.TIMESTAMP,
+    exports.L.TIMESTAMPTZ,
+    exports.L.DATE,
+    exports.L.NUMBER,
+    exports.L.STRING,
+    exports.L.BOOLEAN,
+    exports.L.JSON,
+]);
+// Binary operators that get spaces on both sides at the leaf level.
+// (Chain wrapping for and/or/??/+/- happens at parse-tree level — see
+// formatBinaryChain.)
+exports.BINARY_OPS = new Set([
+    exports.L.PLUS,
+    exports.L.MINUS,
+    exports.L.STAR,
+    exports.L.SLASH,
+    exports.L.PERCENT,
+    exports.L.STARSTAR,
+    exports.L.EQ,
+    exports.L.NE,
+    exports.L.LT,
+    exports.L.GT,
+    exports.L.LTE,
+    exports.L.GTE,
+    exports.L.AND,
+    exports.L.OR,
+    exports.L.MATCH,
+    exports.L.NOT_MATCH,
+    exports.L.ARROW,
+    exports.L.FAT_ARROW,
+    exports.L.BAR,
+    exports.L.AMPER,
+]);
+function leadingAction(prevType, nextType) {
+    if (nextType === exports.L.DOT ||
+        nextType === exports.L.COMMA ||
+        nextType === exports.L.SEMI ||
+        nextType === exports.L.COLON ||
+        nextType === exports.L.TRIPLECOLON ||
+        nextType === exports.L.EXCLAM ||
+        nextType === exports.L.CPAREN ||
+        nextType === exports.L.CBRACK) {
+        return 'glue';
+    }
+    // After the `!` cast operator (`epoch_ms!timestamp(x)`), the next token
+    // glues to it like the `.` operator does.
+    if (prevType === exports.L.EXCLAM)
+        return 'glue';
+    if ((nextType === exports.L.OPAREN || nextType === exports.L.OBRACK) &&
+        prevType !== null &&
+        exports.CALL_HUG_AFTER.has(prevType)) {
+        return 'hug';
+    }
+    return 'space';
+}
+// ---------- Token utilities ----------
+function endLineOf(t) {
+    var _a, _b;
+    const text = (_a = t.text) !== null && _a !== void 0 ? _a : '';
+    const newlines = ((_b = text.match(/\n/g)) !== null && _b !== void 0 ? _b : []).length;
+    return t.line + newlines;
+}
+// Find the index of the closing token that matches the opener at startIdx.
+// Counts nested begin/end pairs of the same types.
+//
+// Precondition: must not be called inside an SQL string region — depth
+// tracking only knows about the begin/end token types passed in, not about
+// embedded SQL. In practice we never call this inside an SQL block (we skip
+// past them).
+function findMatching(tokens, startIdx, beginType, endType) {
+    let depth = 1;
+    for (let j = startIdx + 1; j < tokens.length; j++) {
+        if (tokens[j].type === beginType)
+            depth++;
+        else if (tokens[j].type === endType) {
+            depth--;
+            if (depth === 0)
+                return j;
+        }
+    }
+    return tokens.length - 1;
+}
+//# sourceMappingURL=tokens.js.map

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

@@ -0,0 +1,9 @@
+export interface PrettifyError {
+    message: string;
+    line: number;
+    column: number;
+}
+export interface PrettifyResult {
+    result: string;
+    errors: PrettifyError[];
+}

package/dist/lang/prettify/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/lang/run-malloy-parser.d.ts

@@ -1,3 +1,26 @@
+import { CommonTokenStream } from 'antlr4ts';
+import type { ANTLRErrorListener, Token, CodePointCharStream } from 'antlr4ts';
+import { MalloyParser } from './lib/Malloy/MalloyParser';
 import type { MessageLogger } from './parse-log';
 import type { ParseInfo, SourceInfo } from './utils';
+export interface MalloyParserSetupOptions {
+    lexerErrorListener?: ANTLRErrorListener<any>;
+    parserErrorListener?: ANTLRErrorListener<Token>;
+}
+/**
+ * Build a Malloy lexer/token-stream/parser triplet ready to invoke a grammar
+ * rule on `code`. Centralises the lexer fix (HandlesOverpoppingLexer for
+ * unmatched `}%`) and the project's MalloyErrorStrategy so callers can't
+ * accidentally diverge on those.
+ *
+ * The token stream is NOT pre-filled. Callers that need all tokens up front
+ * (e.g. the prettifier's leaf walker) should call `tokenStream.fill()` before
+ * iterating; callers that only need parser-driven access can leave it alone
+ * — the parser pulls tokens as it consumes the rule.
+ */
+export declare function makeMalloyParser(code: string, options?: MalloyParserSetupOptions): {
+    inputStream: CodePointCharStream;
+    tokenStream: CommonTokenStream;
+    parser: MalloyParser;
+};
 export declare function runMalloyParser(code: string, sourceURL: string, sourceInfo: SourceInfo, logger: MessageLogger, grammarRule?: string): ParseInfo;

package/dist/lang/run-malloy-parser.js

@@ -6,6 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMalloyParser = makeMalloyParser;
 exports.runMalloyParser = runMalloyParser;
 const antlr4ts_1 = require("antlr4ts");
 const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
@@ -24,24 +25,47 @@ class HandlesOverpoppingLexer extends MalloyLexer_1.MalloyLexer {
         return super.popMode();
     }
 }
-function runMalloyParser(code, sourceURL, sourceInfo, logger, grammarRule = 'malloyDocument') {
+/**
+ * Build a Malloy lexer/token-stream/parser triplet ready to invoke a grammar
+ * rule on `code`. Centralises the lexer fix (HandlesOverpoppingLexer for
+ * unmatched `}%`) and the project's MalloyErrorStrategy so callers can't
+ * accidentally diverge on those.
+ *
+ * The token stream is NOT pre-filled. Callers that need all tokens up front
+ * (e.g. the prettifier's leaf walker) should call `tokenStream.fill()` before
+ * iterating; callers that only need parser-driven access can leave it alone
+ * — the parser pulls tokens as it consumes the rule.
+ */
+function makeMalloyParser(code, options = {}) {
     const inputStream = antlr4ts_1.CharStreams.fromString(code);
     const lexer = new HandlesOverpoppingLexer(inputStream);
+    if (options.lexerErrorListener) {
+        lexer.removeErrorListeners();
+        lexer.addErrorListener(options.lexerErrorListener);
+    }
     const tokenStream = new antlr4ts_1.CommonTokenStream(lexer);
-    const malloyParser = new MalloyParser_1.MalloyParser(tokenStream);
-    malloyParser.removeErrorListeners();
-    malloyParser.addErrorListener(new malloy_parser_error_listener_1.MalloyParserErrorListener(logger, sourceURL, sourceInfo));
-    malloyParser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
+    const parser = new MalloyParser_1.MalloyParser(tokenStream);
+    if (options.parserErrorListener) {
+        parser.removeErrorListeners();
+        parser.addErrorListener(options.parserErrorListener);
+    }
+    parser.errorHandler = new malloy_error_strategy_1.MalloyErrorStrategy();
+    return { inputStream, tokenStream, parser };
+}
+function runMalloyParser(code, sourceURL, sourceInfo, logger, grammarRule = 'malloyDocument') {
+    const { inputStream, tokenStream, parser } = makeMalloyParser(code, {
+        parserErrorListener: new malloy_parser_error_listener_1.MalloyParserErrorListener(logger, sourceURL, sourceInfo),
+    });
     // Admitted code smell here, testing likes to parse from an arbitrary
     // node and this is the simplest way to allow that.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const parseFunc = malloyParser[grammarRule];
+    const parseFunc = parser[grammarRule];
     if (!parseFunc) {
         throw new Error(`No such parse rule as ${grammarRule}`);
     }
     return {
-        root: parseFunc.call(malloyParser),
-        tokenStream: tokenStream,
+        root: parseFunc.call(parser),
+        tokenStream,
         sourceStream: inputStream,
         sourceInfo,
         sourceURL,