@voithos-labs/aragonite 0.10.1

package/dist/core/parser.js

@@ -0,0 +1,189 @@
+/**
+ * Single-pass GFM block parser, producing a CST where serialize(parse(source)) === source.
+ * Per-kind parsers live in parsers/; this file holds dispatch and shared utilities only.
+ */
+import { DEV } from 'esm-env';
+import { splitLines } from './lines';
+import { perfEnabled, recordParse } from '../perf/instruments';
+import { defaultGrammarView } from '../schema/block-openers';
+import { assertInvariant } from '../assert';
+import { parseParagraph } from './parsers/paragraph';
+import { registerBuiltInOpeners } from './parsers/built-in-openers';
+import { registerTableCompleter } from './parsers/table-completion';
+registerBuiltInOpeners();
+// The Enter completer is the typed-entry twin of the table grammar, so it loads here rather
+// than behind a side-effect import the production build tree-shakes away.
+registerTableCompleter();
+/**
+ * Container-nesting cap: past it the remaining prefix parses as paragraph content instead of
+ * recursing, so pathological input degrades rather than overflowing the stack. Sits well under
+ * the empirical crash point, with headroom for the tree walks that recurse to the same depth.
+ * Byte-preserving, since only a top-level node's `raw` serializes and that is fixed first.
+ */
+export const MAX_NESTING_DEPTH = 512;
+/**
+ * Parse GFM to a lossless CST. `opts.grammar` is the per-instance grammar view, defaulting to
+ * the global openers. It filters only the TOP-LEVEL opener dispatch: nested container reparses
+ * and the paragraph-interrupt scan read the global grammar, the documented enablement boundary,
+ * so a top-level disabled kind is skipped and a nested one is not. `opts.scope` reaches openers
+ * as `ctx.isDocumentParse`; it defaults to `'document'`, so whole-source callers need nothing.
+ */
+export function parse(source, opts) {
+    const t0 = perfEnabled() ? performance.now() : 0;
+    const lines = splitLines(source);
+    const result = parseBlocks(lines, 0, lines.length, opts?.grammar ?? defaultGrammarView, 0, (opts?.scope ?? 'document') === 'document');
+    if (perfEnabled())
+        recordParse(performance.now() - t0, result.children.length);
+    return { kind: 'document', prefix: '', children: result.children, suffix: result.suffix };
+}
+/**
+ * The seam block-incremental parsing re-parses ranges through: a block-aligned window parses
+ * identically to a full parse of the window's text. A window is a FRAGMENT unless its caller
+ * says otherwise, so `parse` alone defaults to document scope. Blank-line rule
+ * (`design/syntax-tree.md`): the first blank line of a run separates and folds into trivia;
+ * every later one is an empty paragraph carrying its own bytes.
+ */
+export function parseBlocks(lines, start, end, grammar = defaultGrammarView, depth = 0, isDocumentParse = false) {
+    const children = [];
+    let pendingTrivia = '';
+    // Nothing precedes the window's first block, so its separator slot opens already spent —
+    // which is what makes a leading run materialize in full.
+    let separatorSpent = true;
+    let index = start;
+    while (index < end) {
+        const line = lines[index];
+        if (isBlankLine(line.text)) {
+            // A zero-byte line is a container strip's artifact, not one the author wrote: it can
+            // neither separate nor render.
+            if (line.raw !== '') {
+                if (separatorSpent) {
+                    children.push({ kind: 'paragraph', leadingTrivia: pendingTrivia, raw: line.raw });
+                    pendingTrivia = '';
+                }
+                else {
+                    pendingTrivia += line.raw;
+                    separatorSpent = true;
+                }
+            }
+            index++;
+            continue;
+        }
+        // Minted fresh per block, so an opener that retains the context is never re-stamped.
+        const ctx = {
+            lines,
+            index,
+            end,
+            line,
+            leadingTrivia: pendingTrivia,
+            isDocumentParse,
+            grammar,
+            depth
+        };
+        const { node, consumed } = parseNextBlock(ctx);
+        children.push(node);
+        pendingTrivia = '';
+        separatorSpent = false;
+        index += consumed;
+    }
+    return { children, suffix: pendingTrivia };
+}
+/**
+ * Parse a container body between the container's own chrome lines; a body starting at the
+ * container's own first line (blockquote, list item) has no wrap and uses `parse`. A blank line
+ * against a chrome line separates as it does between blocks, landing in `prefix`/`suffix` while
+ * the rest of its run materializes as body content; one with no body on its far side separated
+ * nothing and stays content. `opts.scope` is required: a new entry cannot recover it (G4.27).
+ */
+export function parseContainerBody(bodyText, wrap, opts) {
+    const lines = splitLines(bodyText);
+    let first = 0;
+    let last = lines.length;
+    let prefix = '';
+    let suffix = '';
+    if (wrap.afterOpenerLine && last - first >= 2 && isBlankLine(lines[first].text)) {
+        prefix = lines[first].raw;
+        first++;
+    }
+    if (wrap.beforeCloserLine && last - first >= 2 && isBlankLine(lines[last - 1].text)) {
+        last--;
+        suffix = lines[last].raw;
+    }
+    const inner = parseBlocks(lines, first, last, defaultGrammarView, opts.depth ?? 0, opts.scope === 'document');
+    return { kind: 'document', prefix, children: inner.children, suffix: inner.suffix + suffix };
+}
+// ── Dispatch ────────────────────────────────────────────────────────────
+function parseNextBlock(ctx) {
+    // At the cap everything folds into a paragraph, covering the bytes without another frame.
+    if (ctx.depth >= MAX_NESTING_DEPTH) {
+        return parseParagraph(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia);
+    }
+    for (const opener of ctx.grammar.orderedOpeners()) {
+        const result = opener.tryOpen(ctx);
+        if (!result)
+            continue;
+        if (result.consumed <= 0) {
+            reportNonAdvancingOpener(ctx, result);
+            continue;
+        }
+        if (DEV)
+            assertOpenerRawMatches(ctx, result);
+        return result;
+    }
+    // Paragraph is the total fallback; it also detects setext headings and tables.
+    return parseParagraph(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia);
+}
+/**
+ * The `[invariant:...]` fire behind the call site's decline. An opener that consumed nothing is
+ * declined in every build, not just DEV: returning it would leave `index` put and spin the parse
+ * loop forever, and declining is always safe because the paragraph fallback covers the line.
+ */
+function reportNonAdvancingOpener(ctx, result) {
+    assertInvariant('opener-advance', () => ({
+        code: 'opener-did-not-advance',
+        message: `block opener for kind "${result.node.kind}" claimed no line at ${ctx.index} and was ` +
+            `declined — an opener must consume at least one line (return consumed >= 1)`,
+        detail: result.node.kind
+    }));
+}
+/**
+ * DEV-only trust check on a plugin opener's `raw`, at the one site the parser consumes it:
+ * bytes that do not match the consumed lines silently break the round-trip, since serialize
+ * reads `raw` alone. Tree-shaken in production.
+ */
+function assertOpenerRawMatches(ctx, result) {
+    assertInvariant('opener-raw', () => result.node.raw === joinRaw(ctx.lines, ctx.index, ctx.index + result.consumed)
+        ? null
+        : {
+            code: 'opener-stale-raw',
+            message: `opener for kind "${result.node.kind}" built raw that does not byte-match its ` +
+                `${result.consumed} consumed source line(s)`,
+            detail: result.node.kind
+        });
+}
+// ── Shared utilities ────────────────────────────────────────────────────
+/**
+ * GFM §2.1: a blank line holds nothing but spaces and tabs. Deliberately not `String.trim()`,
+ * which admits all Unicode whitespace: a non-breaking space is content, and a line holding one
+ * continues its block.
+ */
+const NON_BLANK_CHAR = /[^ \t]/;
+export function isBlankLine(text) {
+    return !NON_BLANK_CHAR.test(text);
+}
+/**
+ * Nothing but blank lines — what the blank-line rule mints a block from. Blankness is the
+ * parser's (GFM §2.1), never `String.trim()`: a non-breaking space is content.
+ */
+export function isBlankSource(source) {
+    return splitLines(source).every((line) => isBlankLine(line.text));
+}
+export function isBlankParagraph(node) {
+    return node.kind === 'paragraph' && isBlankSource(node.raw);
+}
+export function joinRaw(lines, startIndex, endIndex) {
+    let result = '';
+    for (let i = startIndex; i < endIndex; i++) {
+        result += lines[i].raw;
+    }
+    return result;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Blockquote parser with CommonMark §5.1 lazy continuation. "Open paragraph" is
+ * approximated per line (non-blank, not a block opener), not tracked as parser state.
+ */
+import { type ParsedLine } from '../lines';
+import { type BlockOpenerResult } from '../../schema/block-openers';
+export declare function matchBlockquote(text: string): boolean;
+/**
+ * Byte-exact `raw` of a blockquote's extent (CommonMark §5.1 lazy continuation) plus the
+ * index past it, no child decomposition: what a blockquote-shaped opener needs when it
+ * decomposes its own body (`> [!NOTE]` alerts strip the marker line before parsing children).
+ */
+export declare function blockquoteExtent(lines: ParsedLine[], startIndex: number, endIndex: number): {
+    raw: string;
+    nextIndex: number;
+};
+export declare function parseBlockquote(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, depth?: number, isDocumentParse?: boolean): BlockOpenerResult;

package/dist/core/parsers/blockquote.js

@@ -0,0 +1,69 @@
+/**
+ * Blockquote parser with CommonMark §5.1 lazy continuation. "Open paragraph" is
+ * approximated per line (non-blank, not a block opener), not tracked as parser state.
+ */
+import { remapStrippedLines } from '../lines';
+import { joinRaw, parseBlocks, isBlankLine } from '../parser';
+import { defaultGrammarView, lineInterruptsParagraph, lineStartsOuterBlock } from '../../schema/block-openers';
+export function matchBlockquote(text) {
+    return /^ {0,3}>/.test(text);
+}
+function stripBlockquotePrefix(text) {
+    return text.replace(/^ {0,3}>[ \t]?/, '');
+}
+/** Lazy continuation extends only an open paragraph, not an open list or other container. */
+function wouldKeepParagraphOpen(strippedText) {
+    if (isBlankLine(strippedText))
+        return false;
+    if (lineInterruptsParagraph(strippedText))
+        return false;
+    if (matchBlockquote(strippedText))
+        return false;
+    return true;
+}
+/**
+ * Byte-exact `raw` of a blockquote's extent (CommonMark §5.1 lazy continuation) plus the
+ * index past it, no child decomposition: what a blockquote-shaped opener needs when it
+ * decomposes its own body (`> [!NOTE]` alerts strip the marker line before parsing children).
+ */
+export function blockquoteExtent(lines, startIndex, endIndex) {
+    let i = startIndex;
+    let paragraphOpen = false;
+    while (i < endIndex) {
+        const lineText = lines[i].text;
+        if (matchBlockquote(lineText)) {
+            const stripped = stripBlockquotePrefix(lineText);
+            paragraphOpen = wouldKeepParagraphOpen(stripped);
+            i++;
+            continue;
+        }
+        if (paragraphOpen &&
+            wouldKeepParagraphOpen(lineText) &&
+            !lineStartsOuterBlock(lines[i], { paragraphOpen: true })) {
+            i++;
+            continue;
+        }
+        break;
+    }
+    return { raw: joinRaw(lines, startIndex, i), nextIndex: i };
+}
+export function parseBlockquote(lines, startIndex, endIndex, leadingTrivia, depth = 0, isDocumentParse = false) {
+    const { raw, nextIndex: i } = blockquoteExtent(lines, startIndex, endIndex);
+    // Lazy lines have no `> ` to strip; verbatim keeps the recursive parse seeing one paragraph.
+    const strippedLines = remapStrippedLines(lines.slice(startIndex, i), (line) => matchBlockquote(line.text) ? stripBlockquotePrefix(line.text) : line.text);
+    const inner = parseBlocks(strippedLines, 0, strippedLines.length, defaultGrammarView, depth + 1, isDocumentParse);
+    const quotePrefix = lines[startIndex].text.match(/^ {0,3}(>[ \t]?)+/)[0];
+    const quoteDepth = quotePrefix.match(/>/g).length;
+    return {
+        node: {
+            kind: 'blockquote',
+            leadingTrivia,
+            raw,
+            metadata: { quoteDepth },
+            innerPrefix: '',
+            children: inner.children,
+            innerSuffix: inner.suffix
+        },
+        consumed: i - startIndex
+    };
+}

package/dist/core/parsers/built-in-openers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Registers the built-in block openers. Lives beside the matchers because
+ * schema/block-kind-descriptor.ts importing them would cycle (parsers/* import
+ * parser.ts, which reads the opener registry). Called explicitly from core/parser.ts: the
+ * `sideEffects` allowlist names dist paths, never the src specifier used here, so a bare
+ * side-effect import would be droppable.
+ */
+export declare function registerBuiltInOpeners(): void;

package/dist/core/parsers/built-in-openers.js

@@ -0,0 +1,124 @@
+/**
+ * Registers the built-in block openers. Lives beside the matchers because
+ * schema/block-kind-descriptor.ts importing them would cycle (parsers/* import
+ * parser.ts, which reads the opener registry). Called explicitly from core/parser.ts: the
+ * `sideEffects` allowlist names dist paths, never the src specifier used here, so a bare
+ * side-effect import would be droppable.
+ */
+import { registerBlockOpener } from '../../schema/block-openers';
+import { OPENER_PRIORITIES } from '../../schema/opener-priorities';
+import { matchFenceOpen } from './fence-syntax';
+import { parseFencedCode } from './fenced-code';
+import { matchHeading } from './heading';
+import { matchThematicBreak } from './thematic-break';
+import { matchBlockquote, parseBlockquote } from './blockquote';
+import { matchListItem, parseList, canInterruptParagraph as listCanInterrupt } from './list';
+import { matchIndentedCode, parseIndentedCode } from './indented-code';
+import { matchHtmlBlock, parseHtmlBlock, canInterruptParagraph as htmlCanInterrupt } from './html-block';
+import { parseLinkReferenceDefinition } from './link-reference';
+// Idempotence guard, not a registry bypass: a dev-server re-eval resets it so
+// the register-once dev valve still replaces.
+let registered = false;
+export function registerBuiltInOpeners() {
+    if (registered)
+        return;
+    registered = true;
+    registerBlockOpener('fencedCode', {
+        priority: OPENER_PRIORITIES.fencedCode,
+        tryOpen(ctx) {
+            const fence = matchFenceOpen(ctx.line.text);
+            if (!fence)
+                return null;
+            return parseFencedCode(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, fence);
+        },
+        interruptsParagraph: (t) => matchFenceOpen(t) !== null
+    });
+    registerBlockOpener('heading', {
+        priority: OPENER_PRIORITIES.heading,
+        tryOpen(ctx) {
+            const heading = matchHeading(ctx.line.text);
+            if (!heading)
+                return null;
+            return {
+                node: {
+                    kind: 'heading',
+                    leadingTrivia: ctx.leadingTrivia,
+                    raw: ctx.line.raw,
+                    metadata: { level: heading.level }
+                },
+                consumed: 1
+            };
+        },
+        interruptsParagraph: (t) => matchHeading(t) !== null
+    });
+    // Setext heading's `---` underline is disambiguated inside parseParagraph;
+    // at dispatch a bare thematic line can't be an underline (no open paragraph).
+    registerBlockOpener('thematicBreak', {
+        priority: OPENER_PRIORITIES.thematicBreak,
+        tryOpen(ctx) {
+            const marker = matchThematicBreak(ctx.line.text);
+            if (!marker)
+                return null;
+            return {
+                node: {
+                    kind: 'thematicBreak',
+                    leadingTrivia: ctx.leadingTrivia,
+                    raw: ctx.line.raw,
+                    metadata: { marker }
+                },
+                consumed: 1
+            };
+        },
+        // `---` is ambiguous with a setext L2 underline, which has first claim.
+        interruptsParagraph: (t) => {
+            const marker = matchThematicBreak(t);
+            return marker === '*' || marker === '_';
+        }
+    });
+    registerBlockOpener('blockquote', {
+        priority: OPENER_PRIORITIES.blockquote,
+        tryOpen(ctx) {
+            if (!matchBlockquote(ctx.line.text))
+                return null;
+            return parseBlockquote(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.depth, ctx.isDocumentParse);
+        },
+        interruptsParagraph: matchBlockquote
+    });
+    registerBlockOpener('list', {
+        priority: OPENER_PRIORITIES.list,
+        tryOpen(ctx) {
+            if (!matchListItem(ctx.line.text))
+                return null;
+            return parseList(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.depth, ctx.isDocumentParse);
+        },
+        interruptsParagraph: listCanInterrupt
+    });
+    registerBlockOpener('indentedCode', {
+        priority: OPENER_PRIORITIES.indentedCode,
+        tryOpen(ctx) {
+            if (!matchIndentedCode(ctx.line.text))
+                return null;
+            return parseIndentedCode(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia);
+        },
+        // GFM §4.4: indented code cannot interrupt a paragraph. An open paragraph absorbs the
+        // indented line lazily, so this opener only sees lines with no paragraph open.
+        interruptsParagraph: false
+    });
+    registerBlockOpener('htmlBlock', {
+        priority: OPENER_PRIORITIES.htmlBlock,
+        tryOpen(ctx) {
+            const type = matchHtmlBlock(ctx.line.text);
+            if (type === null)
+                return null;
+            return parseHtmlBlock(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, type);
+        },
+        interruptsParagraph: htmlCanInterrupt
+    });
+    registerBlockOpener('linkReferenceDefinition', {
+        priority: OPENER_PRIORITIES.linkReferenceDefinition,
+        tryOpen(ctx) {
+            return parseLinkReferenceDefinition(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia);
+        },
+        interruptsParagraph: false
+    });
+}

package/dist/core/parsers/fence-syntax.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The fence grammar's line predicates, split from the block parser so the write-side rule
+ * (`schema/fenced-code-raw.ts`) can read them without pulling `core/parser` into schema.
+ */
+/**
+ * The fence-open shape, re-exported on `@voithos-labs/aragonite/plugin` for fence-claiming openers:
+ * `info` is the trimmed dispatch string; `indent`/`infoRaw` are the verbatim rebuild bytes.
+ */
+export interface FenceOpen {
+    marker: '`' | '~';
+    length: number;
+    info: string;
+    indent: string;
+    infoRaw: string;
+}
+export declare function matchFenceOpen(text: string): FenceOpen | null;
+export declare function matchFenceClose(text: string, marker: '`' | '~', minLength: number): boolean;
+/**
+ * The fence length needed to wrap `body`: one past every body line the parser would read
+ * as this block's closer, never below `minimum`. Without it a body line reproducing the
+ * terminator closes the block early and ejects everything below it on reparse. A floor,
+ * not a target: it never shortens an existing fence.
+ */
+export declare function escalatedFenceLength(body: string, marker: '`' | '~', minimum: number): number;

package/dist/core/parsers/fence-syntax.js

@@ -0,0 +1,44 @@
+/**
+ * The fence grammar's line predicates, split from the block parser so the write-side rule
+ * (`schema/fenced-code-raw.ts`) can read them without pulling `core/parser` into schema.
+ */
+import { escalateTerminatorRun } from '../terminator-escalation';
+// Backtick info may not contain backticks (CommonMark §4.5); tilde info may.
+const BACKTICK_OPEN = /^( {0,3})(`{3,})([^`]*)$/;
+const TILDE_OPEN = /^( {0,3})(~{3,})(.*)$/;
+export function matchFenceOpen(text) {
+    const m = text.match(BACKTICK_OPEN) ?? text.match(TILDE_OPEN);
+    if (!m)
+        return null;
+    const [, indent, fence, infoRaw] = m;
+    return {
+        marker: fence[0],
+        length: fence.length,
+        info: infoRaw.trim(),
+        indent,
+        infoRaw
+    };
+}
+export function matchFenceClose(text, marker, minLength) {
+    const pattern = marker === '`' ? /^ {0,3}(`{3,})\s*$/ : /^ {0,3}(~{3,})\s*$/;
+    const m = text.match(pattern);
+    return Boolean(m && m[1].length >= minLength);
+}
+/**
+ * The fence length needed to wrap `body`: one past every body line the parser would read
+ * as this block's closer, never below `minimum`. Without it a body line reproducing the
+ * terminator closes the block early and ejects everything below it on reparse. A floor,
+ * not a target: it never shortens an existing fence.
+ */
+export function escalatedFenceLength(body, marker, minimum) {
+    return escalateTerminatorRun(body, minimum, (text, required) => matchFenceClose(text, marker, required) ? fenceRunLength(text, marker) : null);
+}
+function fenceRunLength(text, marker) {
+    let index = 0;
+    while (text[index] === ' ')
+        index++;
+    let run = 0;
+    while (text[index + run] === marker)
+        run++;
+    return run;
+}

package/dist/core/parsers/fenced-code.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedLine } from '../lines';
+import type { BlockOpenerResult } from '../../schema/block-openers';
+export declare function parseFencedCode(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, fence: {
+    marker: '`' | '~';
+    length: number;
+    info: string;
+}): BlockOpenerResult;

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

@@ -0,0 +1,29 @@
+import { joinRaw } from '../parser';
+import { matchFenceClose } from './fence-syntax';
+export function parseFencedCode(lines, startIndex, endIndex, leadingTrivia, fence) {
+    let i = startIndex + 1;
+    let closed = false;
+    while (i < endIndex) {
+        if (matchFenceClose(lines[i].text, fence.marker, fence.length)) {
+            i++;
+            closed = true;
+            break;
+        }
+        i++;
+    }
+    const raw = joinRaw(lines, startIndex, i);
+    return {
+        node: {
+            kind: 'fencedCode',
+            leadingTrivia,
+            raw,
+            metadata: {
+                fenceMarker: fence.marker,
+                fenceLength: fence.length,
+                info: fence.info,
+                closed
+            }
+        },
+        consumed: i - startIndex
+    };
+}

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

@@ -0,0 +1,3 @@
+export declare function matchHeading(text: string): {
+    level: number;
+} | null;

package/dist/core/parsers/heading.js

@@ -0,0 +1,6 @@
+// ATX headings only. Setext (`===` / `---` underline) lives in paragraph.ts
+// because it emerges from paragraph continuation.
+export function matchHeading(text) {
+    const m = text.match(/^ {0,3}(#{1,6})(?:\s|$)/);
+    return m ? { level: m[1].length } : null;
+}

package/dist/core/parsers/html-block.d.ts

@@ -0,0 +1,17 @@
+/**
+ * HTML block parser, CommonMark §4.6: seven block types, each with its own close
+ * condition. Types 1-5 close on a per-type pattern; types 6-7 close on a blank line.
+ */
+import type { ParsedLine } from '../lines';
+import type { BlockOpenerResult } from '../../schema/block-openers';
+export type HtmlBlockType = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+/**
+ * Recognize a type-6 tag line for ONE listed tag name, open or close. Built from the same
+ * shape as the type-6 union so a container whose terminator is an html tag line tests the
+ * spec's looseness (`   </details>`, `</DETAILS>`, `<details >`) rather than a copy of it.
+ */
+export declare function htmlBlockTagLineMatcher(tagName: string): (text: string) => 'open' | 'close' | null;
+export declare function matchHtmlBlock(text: string): HtmlBlockType | null;
+/** Types 1-6 interrupt a paragraph; type 7 (catch-all complete tags) cannot, per §4.6. */
+export declare function canInterruptParagraph(text: string): boolean;
+export declare function parseHtmlBlock(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, type: HtmlBlockType): BlockOpenerResult;

package/dist/core/parsers/html-block.js

@@ -0,0 +1,94 @@
+/**
+ * HTML block parser, CommonMark §4.6: seven block types, each with its own close
+ * condition. Types 1-5 close on a per-type pattern; types 6-7 close on a blank line.
+ */
+import { joinRaw, isBlankLine } from '../parser';
+import { OPEN_TAG_SOURCE, CLOSE_TAG_SOURCE } from '../inline/html-tag-grammar';
+// ── Per-type opener patterns ────────────────────────────────────────────────
+// Priority 1 → 7, first match wins. script/pre/style/textarea must stay out of type 6's
+// tag union: they close on their end tag, not on a blank line.
+const TYPE_1_OPEN = /^ {0,3}<(?:script|pre|style|textarea)(?:[\s/>]|$)/i;
+const TYPE_2_OPEN = /^ {0,3}<!--/;
+const TYPE_3_OPEN = /^ {0,3}<\?/;
+const TYPE_4_OPEN = /^ {0,3}<![A-Za-z]/;
+const TYPE_5_OPEN = /^ {0,3}<!\[CDATA\[/;
+const TYPE_6_TAGS = 'address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|template|tfoot|th|thead|title|tr|track|ul';
+function type6Shape(names) {
+    return `^ {0,3}<(/?)(?:${names})(?:[\\s/>]|$)`;
+}
+const TYPE_6_OPEN = new RegExp(type6Shape(TYPE_6_TAGS), 'i');
+/**
+ * Recognize a type-6 tag line for ONE listed tag name, open or close. Built from the same
+ * shape as the type-6 union so a container whose terminator is an html tag line tests the
+ * spec's looseness (`   </details>`, `</DETAILS>`, `<details >`) rather than a copy of it.
+ */
+export function htmlBlockTagLineMatcher(tagName) {
+    const pattern = new RegExp(type6Shape(tagName), 'i');
+    return (text) => {
+        const m = pattern.exec(text);
+        return m === null ? null : m[1] === '/' ? 'close' : 'open';
+    };
+}
+// CommonMark §6.6 complete-tag grammar at line scope, reusing the inline raw-HTML sources
+// (core/inline/html-tag-grammar.ts). Priority LAST: types 1 and 6 claim their names first,
+// which is what implements the spec's exclusion of the type-1 tag names.
+const TYPE_7_OPEN = new RegExp(`^ {0,3}(?:${OPEN_TAG_SOURCE}|${CLOSE_TAG_SOURCE})\\s*$`);
+export function matchHtmlBlock(text) {
+    if (TYPE_1_OPEN.test(text))
+        return 1;
+    if (TYPE_2_OPEN.test(text))
+        return 2;
+    if (TYPE_3_OPEN.test(text))
+        return 3;
+    if (TYPE_4_OPEN.test(text))
+        return 4;
+    if (TYPE_5_OPEN.test(text))
+        return 5;
+    if (TYPE_6_OPEN.test(text))
+        return 6;
+    if (TYPE_7_OPEN.test(text))
+        return 7;
+    return null;
+}
+/** Types 1-6 interrupt a paragraph; type 7 (catch-all complete tags) cannot, per §4.6. */
+export function canInterruptParagraph(text) {
+    const type = matchHtmlBlock(text);
+    return type !== null && type !== 7;
+}
+// ── Per-type close conditions ───────────────────────────────────────────────
+const TYPE_1_CLOSE = /<\/(?:script|pre|style|textarea)>/i;
+function closesOnLine(type, text) {
+    switch (type) {
+        case 1:
+            return TYPE_1_CLOSE.test(text);
+        case 2:
+            return text.includes('-->');
+        case 3:
+            return text.includes('?>');
+        case 4:
+            return text.includes('>');
+        case 5:
+            return text.includes(']]>');
+        case 6:
+        case 7:
+            return isBlankLine(text);
+    }
+}
+// ── Parser ──────────────────────────────────────────────────────────────────
+export function parseHtmlBlock(lines, startIndex, endIndex, leadingTrivia, type) {
+    let i = startIndex;
+    while (i < endIndex) {
+        if (closesOnLine(type, lines[i].text)) {
+            // Types 6-7 leave their closing blank line out so parseBlocks takes it as pendingTrivia.
+            if (type !== 6 && type !== 7)
+                i++;
+            break;
+        }
+        i++;
+    }
+    const raw = joinRaw(lines, startIndex, i);
+    return {
+        node: { kind: 'htmlBlock', leadingTrivia, raw },
+        consumed: i - startIndex
+    };
+}

package/dist/core/parsers/indented-code.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedLine } from '../lines';
+import type { BlockOpenerResult } from '../../schema/block-openers';
+export declare function matchIndentedCode(text: string): boolean;
+export declare function parseIndentedCode(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string): BlockOpenerResult;