@voithos-labs/aragonite 0.10.3 → 0.10.7

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

@@ -1,152 +1,148 @@
 /**
- * Link reference definition parser, CommonMark §4.7 (`[label]: url "title"`, URL and title
- * allowed on continuation lines). Footnote labels (`[^...]:`) are excluded; they stay paragraphs.
+ * Link reference definition parser, CommonMark §4.7 (`[label]: url "title"`). The label,
+ * destination and title are read by the link grammar in `inline/link-destination.ts`, and may
+ * continue on the lines after the first that a paragraph would absorb. Footnote labels
+ * (`[^...]:`) stay paragraphs.
  */
-import { ESCAPABLE_PUNCTUATION } from '../escapable';
+import { isBlankLine, isWhitespaceChar } from '../lines';
 import { joinRaw } from '../parser';
+import { linkTitleValue, parseLinkDestination, scanLinkTitle, scanLinkLabel, SPAN_OPEN } from '../inline/link-destination';
 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);
+    const labelStart = labelOpenerOffset(lines[startIndex].text);
+    if (labelStart < 0)
+        return null;
+    const window = new DefinitionWindow(lines, startIndex, endIndex);
+    const opener = readLabel(window, labelStart);
     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);
+    const destStart = skipSeparator(window, afterColon);
+    const destination = parseLinkDestination(window.text, destStart, window.text.length);
     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);
+    // §4.7: non-whitespace after the destination that isn't a well-formed title on its own line
+    // end means there is no definition; a title that fails on a later line leaves it untitled.
+    let lastOffset = -1;
+    let title;
+    const titleStart = skipSeparator(window, destination.end);
+    if (titleStart > destination.end) {
+        const titleEnd = readSpan(window, titleStart, scanLinkTitle);
+        if (titleEnd >= 0 && atLineEnd(window.text, titleEnd)) {
+            lastOffset = titleEnd;
+            title = linkTitleValue(window.text, titleStart, titleEnd);
+        }
+    }
+    if (lastOffset < 0) {
+        if (!atLineEnd(window.text, destination.end))
+            return null;
+        lastOffset = destination.end;
+    }
+    const endLine = window.lineAt(lastOffset) + 1;
     return {
         node: {
             kind: 'linkReferenceDefinition',
             leadingTrivia,
-            raw,
+            raw: joinRaw(lines, startIndex, endLine),
             metadata: {
                 label,
-                url,
+                url: destination.url,
                 ...(title !== undefined ? { title } : {})
             }
         },
-        consumed: lineCursor + 1 - startIndex
+        consumed: endLine - 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;
+// ── The lines a definition can span ─────────────────────────────────────────
+/** The definition's first line plus each later line a paragraph would continue onto, joined by
+ *  `\n` without leading whitespace (§4.7); a line joins only when a read runs off the end. */
+class DefinitionWindow {
+    lines;
+    startIndex;
+    endIndex;
+    text;
+    /** Offset in `text` where each joined line ends. */
+    lineEnds;
+    next;
+    constructor(lines, startIndex, endIndex) {
+        this.lines = lines;
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+        this.text = lines[startIndex].text;
+        this.lineEnds = [this.text.length];
+        this.next = startIndex + 1;
+    }
+    /** Joins the next line if a paragraph would continue onto it. */
+    grow() {
+        if (this.next >= this.endIndex)
+            return false;
+        const line = this.lines[this.next].text;
+        if (isBlankLine(line) || lineInterruptsParagraph(line) || matchSetextUnderline(line)) {
+            return false;
         }
-        if (ch === ']')
-            break;
-        j++;
+        this.text += '\n' + line.replace(/^[ \t]+/, '');
+        this.lineEnds.push(this.text.length);
+        this.next++;
+        return true;
+    }
+    /** The index into `lines` of the joined line holding `offset`. */
+    lineAt(offset) {
+        let i = 0;
+        while (this.lineEnds[i] < offset)
+            i++;
+        return this.startIndex + i;
     }
-    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 };
+/** Skips spaces and tabs with at most one line ending among them, joining that next line. */
+function skipSeparator(window, pos) {
+    pos = skipSpaces(window.text, pos);
+    if (pos === window.text.length && !window.grow())
+        return pos;
+    return window.text[pos] === '\n' ? skipSpaces(window.text, pos + 1) : pos;
+}
+/** The end of the label or title opening at `pos`, joining lines until it closes, or a miss. */
+function readSpan(window, pos, scan) {
+    let from = pos + 1;
+    for (;;) {
+        const spanEnd = scan(window.text, pos, window.text.length, from);
+        if (spanEnd !== SPAN_OPEN)
+            return spanEnd;
+        from = window.text.length;
+        if (!window.grow())
+            return -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 };
+// The document's last line can end in a lone `\r`, which the line splitter leaves in its text.
+function atLineEnd(text, pos) {
+    pos = skipSpaces(text, pos);
+    if (text[pos] === '\r')
+        pos++;
+    return pos === text.length || text[pos] === '\n';
 }
-/** 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;
+function skipSpaces(text, pos) {
+    while (text[pos] === ' ' || text[pos] === '\t')
+        pos++;
+    return pos;
 }
-/**
- * `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 };
+// ── Label ───────────────────────────────────────────────────────────────────
+/** Where the definition's `[` sits, up to three spaces in, or -1. */
+function labelOpenerOffset(line) {
+    let pos = 0;
+    while (pos < 3 && line[pos] === ' ')
+        pos++;
+    return line[pos] === '[' ? pos : -1;
+}
+/** The label opening at `pos` and the offset past its `]:`. */
+function readLabel(window, pos) {
+    const labelEnd = readSpan(window, pos, scanLinkLabel);
+    if (labelEnd < 0 || window.text[labelEnd] !== ':')
+        return null;
+    const label = window.text.slice(pos + 1, labelEnd - 1);
+    // §6.6: a label holds at least one non-whitespace character, in §2.1's ASCII sense.
+    if ([...label].every(isWhitespaceChar))
+        return null;
+    return { label, afterColon: labelEnd + 1 };
 }

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

@@ -4,16 +4,23 @@
  * 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';
+import { type BlockOpenerResult, type GrammarView } from '../../schema/block-openers';
 export declare function matchListItem(text: string): {
     marker: string;
     ordered: boolean;
     indent: number;
 } | null;
+/** A marker line with nothing after the marker. The gap is required: a bare `-` opens no list. */
+export declare function isContentlessItemLine(text: string): boolean;
 /**
- * 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.
+ * The task marker at the start of `text`, the one reading of its extent: the box, then spaces or
+ * tabs. Never a line ending, so a CRLF line's `\r` stays with the line's ending.
  */
+export declare function matchTaskCheckbox(text: string): {
+    checked: boolean;
+    rawMarker: string;
+} | null;
+/** CommonMark §5.2: a marker interrupts a paragraph only as a bullet or at `1`, with a non-empty
+ *  first item, so "... is 2. bananas" is no list. `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;
+export declare function parseList(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, grammar: GrammarView, depth?: number, isDocumentParse?: boolean): BlockOpenerResult;

package/dist/core/parsers/list.js

@@ -3,11 +3,22 @@
  * 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 { indentColumns, remapStrippedLines, stripIndentColumns } from '../lines';
 import { joinRaw, isBlankLine, parseBlocks } from '../parser';
-import { defaultGrammarView, lineInterruptsParagraph, lineStartsOuterBlock } from '../../schema/block-openers';
+import { lineInterruptsParagraph, lineStartsOuterBlock } from '../../schema/block-openers';
+// ── List markers ─────────────────────────────────────────────────────────────
+// GFM §5.2: a marker, then spaces or tabs. A non-breaking space after the marker is content, so
+// that line opens no item.
+const BULLET = '[-*+]';
+const withDelimiter = (digits) => `${digits}[.)]`;
+const MARKER = `(?:${BULLET}|${withDelimiter('\\d{1,9}')})`;
+const GAP = '[ \\t]+';
+const ITEM_START = new RegExp(`^( {0,3})(${MARKER}${GAP})`);
+const CONTENTLESS_ITEM = new RegExp(`^ {0,3}${MARKER}${GAP}$`);
+// Content after the gap: neither a space or tab nor a line ending the splitter left on the line.
+const INTERRUPTING_ITEM = new RegExp(`^ {0,3}(?:${BULLET}|${withDelimiter('1')})${GAP}[^ \\t\\r\\n]`);
 export function matchListItem(text) {
-    const m = text.match(/^( {0,3})((?:[-*+]|\d{1,9}[.)])\s+)/);
+    const m = text.match(ITEM_START);
     if (!m)
         return null;
     return {
@@ -16,19 +27,24 @@ export function matchListItem(text) {
         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;
+/** A marker line with nothing after the marker. The gap is required: a bare `-` opens no list. */
+export function isContentlessItemLine(text) {
+    return CONTENTLESS_ITEM.test(text);
 }
 /**
- * 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.
+ * The task marker at the start of `text`, the one reading of its extent: the box, then spaces or
+ * tabs. Never a line ending, so a CRLF line's `\r` stays with the line's ending.
  */
+export function matchTaskCheckbox(text) {
+    const m = text.match(/^\[( |x|X)\][ \t]+/);
+    return m ? { checked: m[1].toLowerCase() === 'x', rawMarker: m[0] } : null;
+}
+/** CommonMark §5.2: a marker interrupts a paragraph only as a bullet or at `1`, with a non-empty
+ *  first item, so "... is 2. bananas" is no list. `matchListItem` accepts both. */
 export function canInterruptParagraph(text) {
-    return /^ {0,3}(?:[-*+]|1[.)])[ \t]+\S/.test(text);
+    return INTERRUPTING_ITEM.test(text);
 }
-export function parseList(lines, startIndex, endIndex, leadingTrivia, depth = 0, isDocumentParse = false) {
+export function parseList(lines, startIndex, endIndex, leadingTrivia, grammar, depth = 0, isDocumentParse = false) {
     const firstMatch = matchListItem(lines[startIndex].text);
     const ordered = firstMatch.ordered;
     const items = [];
@@ -42,27 +58,30 @@ export function parseList(lines, startIndex, endIndex, leadingTrivia, depth = 0,
         // 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.
+        // Any line indented to the content column belongs to the body, a whitespace-only one too; a
+        // run of bare blank lines is taken in only when such a line follows it.
         while (i < endIndex) {
-            if (isBlankLine(lines[i].text)) {
+            if (indentColumns(lines[i].text) >= contentIndent) {
+                paragraphOpen = wouldKeepParagraphOpen(stripIndentColumns(lines[i].text, contentIndent));
+                i++;
+            }
+            else if (isBlankLine(lines[i].text)) {
                 let j = i;
-                while (j < endIndex && isBlankLine(lines[j].text))
+                while (j < endIndex &&
+                    isBlankLine(lines[j].text) &&
+                    indentColumns(lines[j].text) < contentIndent) {
                     j++;
-                if (j < endIndex && getIndent(lines[j].text) >= contentIndent) {
-                    paragraphOpen = wouldKeepParagraphOpen(lines[j].text.slice(contentIndent));
-                    i = j + 1;
+                }
+                if (j < endIndex && indentColumns(lines[j].text) >= contentIndent) {
+                    i = j;
                 }
                 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 })) {
+                !lineStartsOuterBlock(lines[i], { paragraphOpen: true, grammar })) {
                 // Lazy continuation: the verbatim bytes stay in raw, and stripListItemLines
                 // feeds the paragraph parser one continuous paragraph.
                 i++;
@@ -73,12 +92,18 @@ export function parseList(lines, startIndex, endIndex, leadingTrivia, depth = 0,
         }
         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.
+        // A leading `[ ] ` is the task marker, and the rest of its line starts the item's paragraph
+        // (GFM task lists). The lines are rebuilt so body offsets match the stripped 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);
+        const inner = parseBlocks(strippedLines, 0, strippedLines.length, {
+            grammar,
+            scope: isDocumentParse ? 'document' : 'fragment',
+            depth: depth + 1,
+            firstLineIsParagraph: task !== null
+        });
         items.push({
             kind: 'listItem',
             leadingTrivia: '',
@@ -108,14 +133,8 @@ export function parseList(lines, startIndex, endIndex, leadingTrivia, depth = 0,
         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.
- */
+/** Lazy continuation extends only an open paragraph. Every list marker is left to the item loop, so
+ *  an ordered marker not at 1 is excluded here too. */
 function wouldKeepParagraphOpen(strippedText) {
     if (isBlankLine(strippedText))
         return false;
@@ -125,9 +144,7 @@ function wouldKeepParagraphOpen(strippedText) {
         return false;
     return true;
 }
+/** The marker line loses its marker; every later line up to `contentIndent` columns. */
 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);
-    });
+    return remapStrippedLines(lines.slice(startIndex, endIndex), (line, i) => i === 0 ? line.text.slice(contentIndent) : stripIndentColumns(line.text, contentIndent));
 }

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

@@ -2,9 +2,9 @@
  * 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;
+import { type ParsedLine } from '../lines';
+import { type BlockOpenerResult, type GrammarView } from '../../schema/block-openers';
+export declare function parseParagraph(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, grammar: GrammarView): BlockOpenerResult;
 export declare function matchSetextUnderline(text: string): {
     level: 1 | 2;
 } | null;

package/dist/core/parsers/paragraph.js

@@ -2,23 +2,30 @@
  * 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 { OPTIONAL_LINE_ENDING } from '../lines';
 import { joinRaw, isBlankLine } from '../parser';
 import { lineInterruptsParagraph } from '../../schema/block-openers';
 import { matchTableDelimiterRow, parseTable, tableHeaderCells } from './table';
-export function parseParagraph(lines, startIndex, endIndex, leadingTrivia) {
+import { matchThematicBreak } from './thematic-break';
+export function parseParagraph(lines, startIndex, endIndex, leadingTrivia, grammar) {
     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);
+            return parseTable(lines, startIndex, endIndex, leadingTrivia, delimiter, grammar);
         }
     }
     let i = startIndex + 1;
     while (i < endIndex && !isBlankLine(lines[i].text) && !lineInterruptsParagraph(lines[i].text)) {
         const setext = matchSetextUnderline(lines[i].text);
-        if (setext) {
+        // With setext headings off, `---` is the thematic break GFM reads once setext is out.
+        if (setext && !grammar.setextHeading) {
+            if (matchThematicBreak(lines[i].text))
+                break;
+        }
+        else if (setext) {
             const raw = joinRaw(lines, startIndex, i + 1);
             return {
                 node: { kind: 'setextHeading', leadingTrivia, raw, metadata: { level: setext.level } },
@@ -33,10 +40,12 @@ export function parseParagraph(lines, startIndex, endIndex, leadingTrivia) {
         consumed: i - startIndex
     };
 }
+const SETEXT_1 = new RegExp(`^ {0,3}=+[ \\t]*${OPTIONAL_LINE_ENDING}$`);
+const SETEXT_2 = new RegExp(`^ {0,3}-+[ \\t]*${OPTIONAL_LINE_ENDING}$`);
 export function matchSetextUnderline(text) {
-    if (/^ {0,3}=+\s*$/.test(text))
+    if (SETEXT_1.test(text))
         return { level: 1 };
-    if (/^ {0,3}-+\s*$/.test(text))
+    if (SETEXT_2.test(text))
         return { level: 2 };
     return null;
 }

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

@@ -4,10 +4,7 @@
  * `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.
- */
+/** Requires a leading pipe on top of the row predicate, since prose carries pipes too
+ *  (`ls | grep foo`); a row the predicate rejects never completes. */
 export declare function tryCompleteTableRow(line: string): CompletionResult | null;
 export declare function registerTableCompleter(): void;

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

@@ -3,20 +3,17 @@
  * 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 { trimTrailingLineEnding, trimWhitespace } 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
+// `parseTable` puts 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.
- */
+/** Requires a leading pipe on top of the row predicate, since prose carries pipes too
+ *  (`ls | grep foo`); a row the predicate rejects never completes. */
 export function tryCompleteTableRow(line) {
-    if (!line.trim().startsWith('|'))
+    if (!trimWhitespace(line).startsWith('|'))
         return null;
     const cells = tableHeaderCells(line);
     if (!cells || cells.length < 2)
@@ -33,8 +30,8 @@ export function tryCompleteTableRow(line) {
 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. */
+/** Through the row rebuilder, so the padding written is the padding the serializer emits. The
+ *  caller owns line endings, so the rebuilder's is trimmed back off. */
 function canonicalRow(cells) {
     const row = {
         kind: 'tableRow',

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

@@ -1,18 +1,18 @@
 import type { TableAlignment } from '../nodes';
-import type { ParsedLine } from '../lines';
-import { type BlockOpenerResult } from '../../schema/block-openers';
+import { type ParsedLine } from '../lines';
+import { type BlockOpenerResult, type GrammarView } 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.
- */
+/** The cells a line offers as a header row, or null: the one definition, so the continuation scan
+ *  and the Enter completer cannot disagree. 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;
+/** Whether a table takes `lines[index]` as one more row, pipe or none: GFM ends a table only at a
+ *  blank line or a block start (spec example 201), judged in the editor's grammar. */
+export declare function tableTakesLine(lines: ParsedLine[], index: number, end: number, grammar: GrammarView): boolean;
 export declare function parseTable(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, delimiter: {
     columnCount: number;
     alignments: TableAlignment[];
-}): BlockOpenerResult;
+}, grammar: GrammarView): BlockOpenerResult;