@voithos-labs/aragonite 0.10.1

package/dist/core/parsers/indented-code.js

@@ -0,0 +1,41 @@
+// The paragraph-interruption guard is dispatch context, not a line-level match, so it lives
+// with the opener registration rather than the matcher.
+import { joinRaw, isBlankLine } from '../parser';
+export function matchIndentedCode(text) {
+    // GFM §2.2: a tab advances to the next 4-column stop, so `  \t` is four columns of indent.
+    let col = 0;
+    for (let i = 0; i < text.length && (text[i] === ' ' || text[i] === '\t'); i++) {
+        col += text[i] === '\t' ? 4 - (col % 4) : 1;
+        if (col >= 4)
+            return true;
+    }
+    return false;
+}
+export function parseIndentedCode(lines, startIndex, endIndex, leadingTrivia) {
+    let i = startIndex;
+    while (i < endIndex) {
+        if (matchIndentedCode(lines[i].text)) {
+            i++;
+        }
+        else if (isBlankLine(lines[i].text)) {
+            // Blank lines stay inside the block only if followed by more indented content.
+            let j = i + 1;
+            while (j < endIndex && isBlankLine(lines[j].text))
+                j++;
+            if (j < endIndex && matchIndentedCode(lines[j].text)) {
+                i = j;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    const raw = joinRaw(lines, startIndex, i);
+    return {
+        node: { kind: 'indentedCode', leadingTrivia, raw },
+        consumed: i - startIndex
+    };
+}

package/dist/core/parsers/link-reference.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Link reference definition parser, CommonMark §4.7 (`[label]: url "title"`, URL and title
+ * allowed on continuation lines). Footnote labels (`[^...]:`) are excluded; they stay paragraphs.
+ */
+import type { ParsedLine } from '../lines';
+import { type BlockOpenerResult } from '../../schema/block-openers';
+export declare function parseLinkReferenceDefinition(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string): BlockOpenerResult | null;

package/dist/core/parsers/link-reference.js

@@ -0,0 +1,152 @@
+/**
+ * Link reference definition parser, CommonMark §4.7 (`[label]: url "title"`, URL and title
+ * allowed on continuation lines). Footnote labels (`[^...]:`) are excluded; they stay paragraphs.
+ */
+import { ESCAPABLE_PUNCTUATION } from '../escapable';
+import { joinRaw } from '../parser';
+import { lineInterruptsParagraph } from '../../schema/block-openers';
+import { matchSetextUnderline } from './paragraph';
+export function parseLinkReferenceDefinition(lines, startIndex, endIndex, leadingTrivia) {
+    const first = lines[startIndex];
+    const opener = matchLabelOpener(first.text);
+    if (!opener)
+        return null;
+    const { label, afterColon } = opener;
+    if (label.startsWith('^'))
+        return null;
+    // Resolve which line the destination sits on first, then run one url + title tail over it.
+    const destination = resolveDestinationSegment(afterColon, lines, startIndex, endIndex);
+    if (!destination)
+        return null;
+    const urlResult = parseUrl(destination.segment);
+    if (!urlResult)
+        return null;
+    const url = urlResult.url;
+    let lineCursor = destination.segmentLine;
+    const afterUrl = stripLeadingSpaces(destination.segment.slice(urlResult.consumed));
+    const tail = resolveTitle(afterUrl, lines, lineCursor + 1, endIndex);
+    if (!tail)
+        return null;
+    const title = tail.title;
+    if (tail.titleLine !== null)
+        lineCursor = tail.titleLine;
+    const raw = joinRaw(lines, startIndex, lineCursor + 1);
+    return {
+        node: {
+            kind: 'linkReferenceDefinition',
+            leadingTrivia,
+            raw,
+            metadata: {
+                label,
+                url,
+                ...(title !== undefined ? { title } : {})
+            }
+        },
+        consumed: lineCursor + 1 - startIndex
+    };
+}
+function stripLeadingSpaces(s) {
+    return s.replace(/^[ \t]*/, '');
+}
+/**
+ * CommonMark §4.7 allows one line ending before the destination, so an empty same-line tail
+ * defers to the next line. A next line that opens a block or underlines the label line as a
+ * setext heading, and an empty one, decline.
+ */
+function resolveDestinationSegment(afterColon, lines, startIndex, endIndex) {
+    const sameLine = stripLeadingSpaces(afterColon);
+    if (sameLine.length > 0)
+        return { segment: sameLine, segmentLine: startIndex };
+    const nextLineIndex = startIndex + 1;
+    if (nextLineIndex >= endIndex)
+        return null;
+    const nextLine = lines[nextLineIndex];
+    if (lineInterruptsParagraph(nextLine.text))
+        return null;
+    if (matchSetextUnderline(nextLine.text))
+        return null;
+    const segment = stripLeadingSpaces(nextLine.text);
+    if (segment.length === 0)
+        return null;
+    return { segment, segmentLine: nextLineIndex };
+}
+// CommonMark §4.7: brackets inside a label may be backslash-escaped. Multi-line labels and
+// unescaped-`[` rejection are out of scope for this line-oriented parser.
+function matchLabelOpener(line) {
+    let i = 0;
+    while (i < line.length && i < 3 && line[i] === ' ')
+        i++;
+    if (line[i] !== '[')
+        return null;
+    const labelStart = i + 1;
+    let j = labelStart;
+    while (j < line.length) {
+        const ch = line[j];
+        if (ch === '\\' && j + 1 < line.length && ESCAPABLE_PUNCTUATION.has(line[j + 1])) {
+            j += 2;
+            continue;
+        }
+        if (ch === ']')
+            break;
+        j++;
+    }
+    if (j >= line.length || line[j] !== ']')
+        return null;
+    if (j + 1 >= line.length || line[j + 1] !== ':')
+        return null;
+    const label = line.slice(labelStart, j);
+    // §4.7: a label holds at least one non-whitespace character.
+    if (label.trim() === '')
+        return null;
+    return { label, afterColon: line.slice(j + 2) };
+}
+function parseUrl(s) {
+    if (s.length === 0)
+        return null;
+    if (s[0] === '<') {
+        const close = s.indexOf('>', 1);
+        if (close === -1)
+            return null;
+        return { url: s.slice(1, close), consumed: close + 1 };
+    }
+    const m = s.match(/^(\S+)/);
+    if (!m)
+        return null;
+    return { url: m[1], consumed: m[1].length };
+}
+const TITLE_CLOSER = { '"': '"', "'": "'", '(': ')' };
+function matchTitleSingleLine(s) {
+    const closer = TITLE_CLOSER[s[0]];
+    if (!closer)
+        return null;
+    const close = s.indexOf(closer, 1);
+    if (close === -1)
+        return null;
+    return { title: s.slice(1, close), consumed: close + 1 };
+}
+/** A title iff `s` holds one well-formed title and nothing but spaces after it. */
+function wholeLineTitle(s) {
+    const t = matchTitleSingleLine(s);
+    if (!t)
+        return null;
+    return stripLeadingSpaces(s.slice(t.consumed)).length === 0 ? { title: t.title } : null;
+}
+/**
+ * `null` invalidates the whole definition (CommonMark §4.7): non-whitespace after the
+ * destination that isn't a well-formed title means it was never a definition. An absent
+ * title succeeds.
+ */
+function resolveTitle(afterUrl, lines, continuationLine, endIndex) {
+    if (afterUrl.length > 0) {
+        const trailing = wholeLineTitle(afterUrl);
+        if (!trailing)
+            return null;
+        return { title: trailing.title, titleLine: null };
+    }
+    if (continuationLine < endIndex) {
+        const next = wholeLineTitle(stripLeadingSpaces(lines[continuationLine].text));
+        if (next)
+            return { title: next.title, titleLine: continuationLine };
+    }
+    return { title: undefined, titleLine: null };
+}

package/dist/core/parsers/list.d.ts

@@ -0,0 +1,19 @@
+/**
+ * List parser with CommonMark §5.2 lazy continuation. "Open paragraph" is approximated per
+ * line (non-blank, not a paragraph interrupter), as in the blockquote parser. Laziness reaches
+ * only the item's own top-level paragraph, never one open inside a nested sub-list.
+ */
+import { type ParsedLine } from '../lines';
+import { type BlockOpenerResult } from '../../schema/block-openers';
+export declare function matchListItem(text: string): {
+    marker: string;
+    ordered: boolean;
+    indent: number;
+} | null;
+/**
+ * CommonMark §5.2: a marker interrupts a paragraph only if bullet or starting at `1` AND its
+ * first item is non-empty, so neither "... is 2. bananas" nor a content-less marker is a list.
+ * Standalone list parsing (`matchListItem`) accepts both.
+ */
+export declare function canInterruptParagraph(text: string): boolean;
+export declare function parseList(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, depth?: number, isDocumentParse?: boolean): BlockOpenerResult;

package/dist/core/parsers/list.js

@@ -0,0 +1,133 @@
+/**
+ * List parser with CommonMark §5.2 lazy continuation. "Open paragraph" is approximated per
+ * line (non-blank, not a paragraph interrupter), as in the blockquote parser. Laziness reaches
+ * only the item's own top-level paragraph, never one open inside a nested sub-list.
+ */
+import { remapStrippedLines } from '../lines';
+import { joinRaw, isBlankLine, parseBlocks } from '../parser';
+import { defaultGrammarView, lineInterruptsParagraph, lineStartsOuterBlock } from '../../schema/block-openers';
+export function matchListItem(text) {
+    const m = text.match(/^( {0,3})((?:[-*+]|\d{1,9}[.)])\s+)/);
+    if (!m)
+        return null;
+    return {
+        marker: m[2],
+        ordered: /^\d/.test(m[2]),
+        indent: m[0].length
+    };
+}
+function matchTaskCheckbox(text) {
+    const m = text.match(/^\[( |x|X)\]\s+/);
+    return m ? { checked: m[1].toLowerCase() === 'x', rawMarker: m[0] } : null;
+}
+/**
+ * CommonMark §5.2: a marker interrupts a paragraph only if bullet or starting at `1` AND its
+ * first item is non-empty, so neither "... is 2. bananas" nor a content-less marker is a list.
+ * Standalone list parsing (`matchListItem`) accepts both.
+ */
+export function canInterruptParagraph(text) {
+    return /^ {0,3}(?:[-*+]|1[.)])[ \t]+\S/.test(text);
+}
+export function parseList(lines, startIndex, endIndex, leadingTrivia, depth = 0, isDocumentParse = false) {
+    const firstMatch = matchListItem(lines[startIndex].text);
+    const ordered = firstMatch.ordered;
+    const items = [];
+    let i = startIndex;
+    while (i < endIndex) {
+        const itemMatch = matchListItem(lines[i].text);
+        if (!itemMatch || itemMatch.ordered !== ordered)
+            break;
+        const contentIndent = itemMatch.indent;
+        const itemStartIndex = i;
+        // The marker line strips to its content; a paragraph is open unless that content opens a block.
+        let paragraphOpen = wouldKeepParagraphOpen(lines[i].text.slice(contentIndent));
+        i++;
+        // Blank lines are absorbed if followed by indented content, making multi-paragraph items.
+        while (i < endIndex) {
+            if (isBlankLine(lines[i].text)) {
+                let j = i;
+                while (j < endIndex && isBlankLine(lines[j].text))
+                    j++;
+                if (j < endIndex && getIndent(lines[j].text) >= contentIndent) {
+                    paragraphOpen = wouldKeepParagraphOpen(lines[j].text.slice(contentIndent));
+                    i = j + 1;
+                }
+                else {
+                    break;
+                }
+            }
+            else if (getIndent(lines[i].text) >= contentIndent) {
+                paragraphOpen = wouldKeepParagraphOpen(lines[i].text.slice(contentIndent));
+                i++;
+            }
+            else if (paragraphOpen &&
+                wouldKeepParagraphOpen(lines[i].text) &&
+                !lineStartsOuterBlock(lines[i], { paragraphOpen: true })) {
+                // Lazy continuation: the verbatim bytes stay in raw, and stripListItemLines
+                // feeds the paragraph parser one continuous paragraph.
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        const itemRaw = joinRaw(lines, itemStartIndex, i);
+        const baseLines = stripListItemLines(lines, itemStartIndex, i, contentIndent);
+        // A leading `[ ] ` is the task marker; re-mint so body offsets match its shortened bytes.
+        const task = matchTaskCheckbox(baseLines.length > 0 ? baseLines[0].text : '');
+        const strippedLines = task
+            ? remapStrippedLines(baseLines, (line, index) => index === 0 ? line.text.slice(task.rawMarker.length) : line.text)
+            : baseLines;
+        const inner = parseBlocks(strippedLines, 0, strippedLines.length, defaultGrammarView, depth + 1, isDocumentParse);
+        items.push({
+            kind: 'listItem',
+            leadingTrivia: '',
+            raw: itemRaw,
+            metadata: {
+                marker: itemMatch.marker,
+                taskItem: task !== null,
+                taskChecked: task?.checked ?? false,
+                taskMarker: task?.rawMarker ?? null
+            },
+            innerPrefix: '',
+            children: inner.children,
+            innerSuffix: inner.suffix
+        });
+    }
+    const raw = joinRaw(lines, startIndex, i);
+    return {
+        node: {
+            kind: 'list',
+            leadingTrivia,
+            raw,
+            metadata: { ordered },
+            innerPrefix: '',
+            children: items,
+            innerSuffix: ''
+        },
+        consumed: i - startIndex
+    };
+}
+function getIndent(text) {
+    return text.match(/^ */)[0].length;
+}
+/**
+ * Lazy continuation extends only an open paragraph. Any list marker is block-level, resolved
+ * by the outer item loop, so an ordered marker not starting at 1 is excluded here even though
+ * §5.2 says it cannot interrupt a paragraph.
+ */
+function wouldKeepParagraphOpen(strippedText) {
+    if (isBlankLine(strippedText))
+        return false;
+    if (matchListItem(strippedText))
+        return false;
+    if (lineInterruptsParagraph(strippedText))
+        return false;
+    return true;
+}
+function stripListItemLines(lines, startIndex, endIndex, contentIndent) {
+    return remapStrippedLines(lines.slice(startIndex, endIndex), (line, i) => {
+        const stripCount = i === 0 ? contentIndent : Math.min(getIndent(line.text), contentIndent);
+        return line.text.slice(stripCount);
+    });
+}

package/dist/core/parsers/paragraph.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Paragraph fallback. Owns setext-heading and table detection too: both emerge from
+ * paragraph continuation (next-line lookahead), not from their own top-level matchers.
+ */
+import type { ParsedLine } from '../lines';
+import { type BlockOpenerResult } from '../../schema/block-openers';
+export declare function parseParagraph(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string): BlockOpenerResult;
+export declare function matchSetextUnderline(text: string): {
+    level: 1 | 2;
+} | null;

package/dist/core/parsers/paragraph.js

@@ -0,0 +1,42 @@
+/**
+ * Paragraph fallback. Owns setext-heading and table detection too: both emerge from
+ * paragraph continuation (next-line lookahead), not from their own top-level matchers.
+ */
+import { joinRaw, isBlankLine } from '../parser';
+import { lineInterruptsParagraph } from '../../schema/block-openers';
+import { matchTableDelimiterRow, parseTable, tableHeaderCells } from './table';
+export function parseParagraph(lines, startIndex, endIndex, leadingTrivia) {
+    if (startIndex + 1 < endIndex) {
+        const delimiter = matchTableDelimiterRow(lines[startIndex + 1].text);
+        const header = tableHeaderCells(lines[startIndex].text);
+        // GFM §4.10: a header/delimiter count mismatch is no table; accepting it would
+        // truncate surplus header cells out of the model.
+        if (delimiter && header && header.length === delimiter.columnCount) {
+            return parseTable(lines, startIndex, endIndex, leadingTrivia, delimiter);
+        }
+    }
+    let i = startIndex + 1;
+    while (i < endIndex && !isBlankLine(lines[i].text) && !lineInterruptsParagraph(lines[i].text)) {
+        const setext = matchSetextUnderline(lines[i].text);
+        if (setext) {
+            const raw = joinRaw(lines, startIndex, i + 1);
+            return {
+                node: { kind: 'setextHeading', leadingTrivia, raw, metadata: { level: setext.level } },
+                consumed: i + 1 - startIndex
+            };
+        }
+        i++;
+    }
+    const raw = joinRaw(lines, startIndex, i);
+    return {
+        node: { kind: 'paragraph', leadingTrivia, raw },
+        consumed: i - startIndex
+    };
+}
+export function matchSetextUnderline(text) {
+    if (/^ {0,3}=+\s*$/.test(text))
+        return { level: 1 };
+    if (/^ {0,3}-+\s*$/.test(text))
+        return { level: 2 };
+    return null;
+}

package/dist/core/parsers/table-completion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The table's Enter completer: a lone header-shaped row completes into that header, the
+ * canonical delimiter row and one empty body row, caret in the first body cell. Registered from
+ * `core/parser.ts`, the guaranteed load path the built-in openers already ride.
+ */
+import { type CompletionResult } from '../../schema/block-completions';
+/**
+ * A leading pipe on top of the parser's row predicate: prose carries pipes too (`ls | grep foo`),
+ * which the scan alone would take as a two-cell header. The predicate stays the outer bound — a
+ * row it rejects never completes.
+ */
+export declare function tryCompleteTableRow(line: string): CompletionResult | null;
+export declare function registerTableCompleter(): void;

package/dist/core/parsers/table-completion.js

@@ -0,0 +1,48 @@
+/**
+ * The table's Enter completer: a lone header-shaped row completes into that header, the
+ * canonical delimiter row and one empty body row, caret in the first body cell. Registered from
+ * `core/parser.ts`, the guaranteed load path the built-in openers already ride.
+ */
+import { trimTrailingLineEnding } from '../lines';
+import { registerBlockCompleter } from '../../schema/block-completions';
+import { writeTableRow } from '../../schema/container-rebuilders';
+import { tableHeaderCells } from './table';
+// `parseTable` seats the header at child 0 and synthesizes the delimiter from metadata, so the
+// first body row is child 1.
+const FIRST_BODY_CELL = [1, 0];
+/**
+ * A leading pipe on top of the parser's row predicate: prose carries pipes too (`ls | grep foo`),
+ * which the scan alone would take as a two-cell header. The predicate stays the outer bound — a
+ * row it rejects never completes.
+ */
+export function tryCompleteTableRow(line) {
+    if (!line.trim().startsWith('|'))
+        return null;
+    const cells = tableHeaderCells(line);
+    if (!cells || cells.length < 2)
+        return null;
+    return {
+        lines: [
+            canonicalRow(cells),
+            canonicalRow(cells.map(() => '---')),
+            canonicalRow(cells.map(() => ''))
+        ],
+        caret: { path: FIRST_BODY_CELL, line: 0, column: 0 }
+    };
+}
+export function registerTableCompleter() {
+    registerBlockCompleter('table', { tryComplete: tryCompleteTableRow });
+}
+/** Through the row rebuilder, so minted padding is the padding the serializer emits. The seam
+ *  owns line endings, so the rebuilder's is trimmed back off. */
+function canonicalRow(cells) {
+    const row = {
+        kind: 'tableRow',
+        leadingTrivia: '',
+        raw: '',
+        metadata: { isHeader: false },
+        children: cells.map((raw) => ({ kind: 'tableCell', leadingTrivia: '', raw }))
+    };
+    writeTableRow(row, '\n');
+    return trimTrailingLineEnding(row.raw);
+}

package/dist/core/parsers/table.d.ts

@@ -0,0 +1,18 @@
+import type { TableAlignment } from '../nodes';
+import type { ParsedLine } from '../lines';
+import { type BlockOpenerResult } from '../../schema/block-openers';
+export declare function splitRowCells(rowText: string): string[];
+/**
+ * The cells a line offers as a table header row, or null when it offers none — the one home for
+ * the shape, so a row the continuation scan accepts and the Enter completer refuses cannot exist.
+ * Arity against the delimiter is the caller's check.
+ */
+export declare function tableHeaderCells(text: string): string[] | null;
+export declare function matchTableDelimiterRow(text: string): {
+    columnCount: number;
+    alignments: TableAlignment[];
+} | null;
+export declare function parseTable(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, delimiter: {
+    columnCount: number;
+    alignments: TableAlignment[];
+}): BlockOpenerResult;

package/dist/core/parsers/table.js

@@ -0,0 +1,110 @@
+import { joinRaw, isBlankLine } from '../parser';
+import { lineStartsOuterBlock } from '../../schema/block-openers';
+// ── Cell splitter ──────────────────────────────────────────────────────────
+// Cell padding is cosmetic. Pre-edit bytes survive in `table.raw`; post-edit,
+// rebuildTableRowRaw emits canonical single-space padding for every row.
+export function splitRowCells(rowText) {
+    const trimmed = rowText.trim();
+    const head = trimmed.startsWith('|') ? trimmed.slice(1) : trimmed;
+    const inner = head.endsWith('|') ? head.slice(0, -1) : head;
+    const cells = [];
+    let current = '';
+    let escaped = false;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '|' && !escaped) {
+            cells.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += ch;
+        escaped = ch === '\\' && !escaped;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+/**
+ * The cells a line offers as a table header row, or null when it offers none — the one home for
+ * the shape, so a row the continuation scan accepts and the Enter completer refuses cannot exist.
+ * Arity against the delimiter is the caller's check.
+ */
+export function tableHeaderCells(text) {
+    if (!text.includes('|'))
+        return null;
+    return splitRowCells(text);
+}
+// ── Delimiter row ──────────────────────────────────────────────────────────
+export function matchTableDelimiterRow(text) {
+    const trimmed = text.trim();
+    if (!trimmed.includes('|'))
+        return null;
+    const inner = trimmed.replace(/^\||\|$/g, '');
+    const cells = inner.split('|');
+    const alignments = [];
+    for (const cell of cells) {
+        const c = cell.trim();
+        if (!/^:?-+:?$/.test(c))
+            return null;
+        const left = c.startsWith(':');
+        const right = c.endsWith(':');
+        if (left && right)
+            alignments.push('center');
+        else if (left)
+            alignments.push('left');
+        else if (right)
+            alignments.push('right');
+        else
+            alignments.push('none');
+    }
+    return { columnCount: cells.length, alignments };
+}
+// ── Block parser ───────────────────────────────────────────────────────────
+export function parseTable(lines, startIndex, endIndex, leadingTrivia, delimiter) {
+    // GFM: the table breaks at a blank line or the start of another block, so a body row is a
+    // pipe-carrying line no opener claims. No paragraph is open here, so nothing is transparent
+    // but the definition, which is never a block start.
+    let i = startIndex + 2;
+    while (i < endIndex &&
+        !isBlankLine(lines[i].text) &&
+        lines[i].text.includes('|') &&
+        !lineStartsOuterBlock(lines[i], { paragraphOpen: false })) {
+        i++;
+    }
+    const rows = [];
+    rows.push(buildRow(lines[startIndex], delimiter.columnCount, true));
+    for (let r = startIndex + 2; r < i; r++) {
+        rows.push(buildRow(lines[r], delimiter.columnCount, false));
+    }
+    const raw = joinRaw(lines, startIndex, i);
+    return {
+        node: {
+            kind: 'table',
+            leadingTrivia,
+            raw,
+            metadata: { columnCount: delimiter.columnCount, alignments: delimiter.alignments },
+            children: rows
+        },
+        consumed: i - startIndex
+    };
+}
+// GFM pads short BODY rows and truncates long ones to the delimiter column count. The header
+// always matches: a mismatch rejects the whole table at recognition (GFM §4.10, paragraph.ts).
+function buildRow(line, columnCount, isHeader) {
+    const cellTexts = splitRowCells(line.text);
+    while (cellTexts.length < columnCount)
+        cellTexts.push('');
+    if (cellTexts.length > columnCount)
+        cellTexts.length = columnCount;
+    const cells = cellTexts.map((text) => ({
+        kind: 'tableCell',
+        leadingTrivia: '',
+        raw: text
+    }));
+    return {
+        kind: 'tableRow',
+        leadingTrivia: '',
+        raw: line.raw,
+        metadata: { isHeader },
+        children: cells
+    };
+}

package/dist/core/parsers/thematic-break.d.ts

@@ -0,0 +1 @@
+export declare function matchThematicBreak(text: string): string | null;

package/dist/core/parsers/thematic-break.js

@@ -0,0 +1,19 @@
+// Ambiguity with setext underlines is resolved in paragraph.ts; top-level
+// dispatch only reaches here after a blank line or a non-paragraph state.
+export function matchThematicBreak(text) {
+    // CommonMark §4.1: 0-3 columns of indent; 4+ is indented code (tabs advance to the next 4).
+    let col = 0;
+    for (let i = 0; i < text.length && (text[i] === ' ' || text[i] === '\t'); i++) {
+        col += text[i] === '\t' ? 4 - (col % 4) : 1;
+        if (col >= 4)
+            return null;
+    }
+    const trimmed = text.trim();
+    if (/^(\*[ \t]*){3,}$/.test(trimmed))
+        return '*';
+    if (/^(-[ \t]*){3,}$/.test(trimmed))
+        return '-';
+    if (/^(_[ \t]*){3,}$/.test(trimmed))
+        return '_';
+    return null;
+}

package/dist/core/serializer.d.ts

@@ -0,0 +1,15 @@
+interface Serializable {
+    readonly prefix: string;
+    readonly children: readonly {
+        readonly leadingTrivia: string;
+        readonly raw: string;
+    }[];
+    readonly suffix: string;
+}
+/** The one child-join: container rebuilders and serialize() share it. */
+export declare function concatChildren(children: readonly {
+    readonly leadingTrivia: string;
+    readonly raw: string;
+}[]): string;
+export declare function serialize(document: Serializable): string;
+export {};

package/dist/core/serializer.js

@@ -0,0 +1,11 @@
+// Structurally typed so nested containers and readonly node views serialize without a class.
+/** The one child-join: container rebuilders and serialize() share it. */
+export function concatChildren(children) {
+    let out = '';
+    for (const c of children)
+        out += c.leadingTrivia + c.raw;
+    return out;
+}
+export function serialize(document) {
+    return document.prefix + concatChildren(document.children) + document.suffix;
+}

package/dist/core/terminator-escalation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The walk behind every "widen the opener past its own body" rule: raise `minimum` one past
+ * each body line that would close the block at the width reached so far. A core leaf because
+ * the fence grammar and the directive grammar both need it, and neither should import the
+ * other's directory. Per-syntax knowledge stays in `closerRun`, which reports the closing
+ * line's run length or `null` for a line that does not close.
+ */
+export declare function escalateTerminatorRun(body: string, minimum: number, closerRun: (text: string, required: number) => number | null): number;