@texuli/deck 0.0.0-stage → 0.5.0

package/dist/markdown/blocks.js

@@ -0,0 +1,766 @@
+/**
+ * The block reader: one slide's lines → a flat list of nodes with source
+ * positions. It recognizes the dialect's block constructs (headings,
+ * paragraphs, lists, quotes, pipe tables, image lines, rules, code and math
+ * fences, `:::` directives, attribute comments and `Note:`), refuses HTML,
+ * and keeps inline text as the Markdown string `@texuli/blocks` paints. One
+ * pass; every loop advances at least one line.
+ */
+import { LINK_HREF_PATTERN, MEDIA_SRC_PATTERN } from "../model/shared.js";
+import { readAttributes } from "./attributes.js";
+import { DECK_MARKDOWN_LIMITS } from "./limits.js";
+import { trimBlankEnd } from "./text.js";
+/** Directives whose body is one JSON value. */
+export const JSON_DIRECTIVES = new Set(['component', 'block', 'custom', 'props', 'slide', 'chart']);
+/** Directives whose body is Markdown (layout regions). */
+export const REGION_DIRECTIVES = new Set(['left', 'right', 'card', 'video']);
+/*
+ * Linear by construction: the patterns below run on lines with no line
+ * terminator (see `normalizeLines`), and the ones that ended in `[ \t]*$`
+ * after a lazy or greedy capture now run on `trimBlankEnd(text)` and end in
+ * `$`, so no two quantifiers compete for the same spaces. Image lines and
+ * table alignment rows are scanned by index (`matchImageLine`, `isAlignRow`).
+ */
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*))?$/;
+const RULE = /^ {0,3}(?:\*[ \t]*){3,}$|^ {0,3}(?:_[ \t]*){3,}$/;
+const BULLET = /^( {0,3})([-*+])[ \t]+(.*)$/;
+const ORDERED = /^( {0,3})(\d{1,9})([.)])[ \t]+(.*)$/;
+const QUOTE = /^ {0,3}>[ ]?(.*)$/;
+const FENCE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+const MATH_OPEN = /^ {0,3}\$\$[ \t]*$/;
+const MATH_LINE = /^ {0,3}\$\$(.+)\$\$$/;
+const DIRECTIVE = /^ {0,3}:::[ \t]*([A-Za-z][A-Za-z0-9-]*)?(.*)$/;
+const DIRECTIVE_CLOSE = /^ {0,3}:::[ \t]*$/;
+const NOTE = /^(?:Notes?|notes?):(?:[ \t]?(.*))?$/;
+/**
+ * Notes lines the writer escapes with a leading `\`: separators and fence
+ * openers, which the slide splitter would otherwise read.
+ */
+export const NOTE_ESCAPED = /^\\(?=-{2,}[ \t]*$| {0,3}(?::::|`{3}|~{3}|\$\$))/;
+const TABLE_ROW = /^ {0,3}\|/;
+const HTML_LINE = /^ {0,3}<[A-Za-z/!?]/;
+const AUTOLINK = /^ {0,3}<(?:https?:\/\/|mailto:)/i;
+const LINE_SPEC = /^\d{1,4}(?:-\d{1,4})?(?:,\d{1,4}(?:-\d{1,4})?)*$/;
+const LANG = /^[a-z][a-z0-9+-]{0,31}$/;
+const LINK_HREF = new RegExp(LINK_HREF_PATTERN, 'u');
+const MEDIA_SRC = new RegExp(MEDIA_SRC_PATTERN, 'u');
+/** True for an HTML tag at the start of a line (comments and autolinks are not tags). */
+function isHtmlLine(text) {
+    return HTML_LINE.test(text) && !text.trimStart().startsWith('<!--') && !AUTOLINK.test(text);
+}
+/** `\s` as the regex class reads it (spaces, tabs, Unicode spaces). */
+function isSpace(char) {
+    return char !== undefined && /\s/.test(char);
+}
+/**
+ * An image alone on its line: `![alt](url "title")`, with `<url>` allowed.
+ * Scanned by index: the regex it replaces (`\(\s*<?([^\s<>]*)>?(?:\s+"…")?\s*\)`)
+ * backtracked over a long run of spaces between the parentheses.
+ */
+export function matchImageLine(line) {
+    const text = trimBlankEnd(line);
+    let i = 0;
+    while (i < 3 && text[i] === ' ')
+        i++;
+    if (!text.startsWith('![', i))
+        return null;
+    const altEnd = text.indexOf(']', i + 2);
+    if (altEnd < 0 || text[altEnd + 1] !== '(' || !text.endsWith(')'))
+        return null;
+    const alt = text.slice(i + 2, altEnd);
+    const inner = text.slice(altEnd + 2, text.length - 1);
+    let at = 0;
+    while (isSpace(inner[at]))
+        at++;
+    if (inner[at] === '<')
+        at++;
+    const urlStart = at;
+    while (at < inner.length && !isSpace(inner[at]) && inner[at] !== '<' && inner[at] !== '>')
+        at++;
+    const url = inner.slice(urlStart, at);
+    if (inner[at] === '>')
+        at++;
+    const gap = at;
+    while (isSpace(inner[at]))
+        at++;
+    if (at === inner.length)
+        return { alt, url };
+    // A title needs a space before it and only spaces after it.
+    if (at === gap || inner[at] !== '"')
+        return null;
+    const close = inner.indexOf('"', at + 1);
+    if (close < 0)
+        return null;
+    let end = close + 1;
+    while (isSpace(inner[end]))
+        end++;
+    if (end !== inner.length)
+        return null;
+    return { alt, url, title: inner.slice(at + 1, close) };
+}
+/** `[ \t]` trimmed off both ends, by index. */
+function trimBlank(text) {
+    let start = 0;
+    while (text[start] === ' ' || text[start] === '\t')
+        start++;
+    return trimBlankEnd(text.slice(start));
+}
+const ALIGN_CELL = /^:?-+:?$/;
+/**
+ * A table alignment row (`| :--- | ---: |`): split on `|`, every cell
+ * `:?-+:?` between spaces or tabs; outer pipes optional. Scanned by
+ * splitting: the single regex it replaces backtracked across cells.
+ */
+export function isAlignRow(line) {
+    let text = line;
+    let i = 0;
+    while (i < 3 && text[i] === ' ')
+        i++;
+    text = text.slice(text[i] === '|' ? i + 1 : i);
+    text = trimBlankEnd(text);
+    if (text.endsWith('|'))
+        text = text.slice(0, -1);
+    const cells = text.split('|');
+    for (const cell of cells)
+        if (!ALIGN_CELL.test(trimBlank(cell)))
+            return false;
+    return true;
+}
+/** Split a trailing `<!-- .element: … -->` off a line. */
+function trailingElement(text) {
+    const at = text.lastIndexOf('<!--');
+    if (at <= 0)
+        return null;
+    const tail = /^<!--[ \t]*\.element:(.*)-->$/.exec(trimBlankEnd(text.slice(at)));
+    if (!tail || (tail[1] ?? '').includes('-->'))
+        return null;
+    return {
+        text: trimBlankEnd(text.slice(0, at)),
+        attrs: tail[1] ?? '',
+        column: at + 1 + text.slice(at).indexOf(':') + 1,
+    };
+}
+class Reader {
+    lines;
+    sink;
+    i = 0;
+    slideAttrs = [];
+    notes;
+    constructor(lines, sink) {
+        this.lines = lines;
+        this.sink = sink;
+    }
+    src(line, column = 1) {
+        return { line: line.n, column };
+    }
+    /** Read element attributes from comment text at `line`/`column`. */
+    elementAttrs(text, line, column) {
+        return { list: readAttributes(text, line, column, this.sink), src: { line, column } };
+    }
+    /** Read nodes until the end, or until a bare `:::` when `inRegion`. */
+    nodes(depth, inRegion) {
+        const out = [];
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            const text = line.text;
+            if (text.trim() === '') {
+                this.i++;
+                continue;
+            }
+            if (DIRECTIVE_CLOSE.test(text)) {
+                this.i++;
+                if (inRegion)
+                    return { nodes: out, closed: true };
+                this.sink.report('md-region-unknown', 'A `:::` closes nothing.', this.src(line));
+                continue;
+            }
+            if (!inRegion) {
+                const note = NOTE.exec(text);
+                if (note) {
+                    this.readNotes(note[1] ?? '', line);
+                    return { nodes: out, closed: false };
+                }
+            }
+            const trimmed = text.trimStart();
+            if (trimmed.startsWith('<!--')) {
+                this.comment(line, out, inRegion);
+                continue;
+            }
+            if (isHtmlLine(text)) {
+                const iframe = /^<\/?iframe\b/i.test(trimmed);
+                this.sink.report(iframe ? 'md-iframe-refused' : 'md-html-refused', iframe ? 'iframes are refused.' : 'Raw HTML is refused; this line renders nothing.', this.src(line, text.length - trimmed.length + 1), [], iframe
+                    ? 'Place a catalog component with `::: component <id>` instead.'
+                    : 'Use Markdown, a `layout` with `:::` regions, or `::: component <id>`.');
+                this.i++;
+                continue;
+            }
+            const node = this.block(depth);
+            if (node)
+                out.push(node);
+        }
+        if (inRegion)
+            return { nodes: out, closed: false };
+        return { nodes: out, closed: true };
+    }
+    readNotes(first, line) {
+        const parts = [first];
+        for (this.i++; this.i < this.lines.length; this.i++) {
+            parts.push(this.lines[this.i].text);
+        }
+        const text = parts
+            .map((part) => part.replace(NOTE_ESCAPED, ''))
+            .join('\n')
+            .trimEnd();
+        this.notes = { text, src: this.src(line) };
+    }
+    comment(line, out, inRegion) {
+        const text = line.text.trim();
+        const kind = /^<!--[ \t]*\.(slide|element):/.exec(text);
+        if (kind) {
+            const close = text.lastIndexOf('-->');
+            const head = kind[0].length;
+            const column = line.text.indexOf('<!--') + 1;
+            if (close < head || !text.endsWith('-->')) {
+                this.sink.report('md-attr-value', `An \`.${kind[1]}\` comment must open and close on one line.`, this.src(line, column));
+                this.i++;
+                return;
+            }
+            const body = text.slice(head, close);
+            const bodyColumn = column + head;
+            if (kind[1] === 'slide') {
+                if (inRegion) {
+                    this.sink.report('md-attr-value', '`.slide` attributes belong at the top level of a slide, not inside a region.', this.src(line, column));
+                }
+                else
+                    this.slideAttrs.push(...readAttributes(body, line.n, bodyColumn, this.sink));
+            }
+            else {
+                const target = out[out.length - 1];
+                if (!target) {
+                    this.sink.report('md-element-orphan', 'This `.element` comment has no element before it.', this.src(line, column), [], 'Put it at the end of the element’s line, or on the line right after the element.');
+                }
+                else
+                    this.attach(target, this.elementAttrs(body, line.n, bodyColumn));
+            }
+            this.i++;
+            return;
+        }
+        // A plain comment: dropped, possibly over several lines.
+        for (let j = this.i; j < this.lines.length; j++) {
+            const candidate = this.lines[j].text;
+            const from = j === this.i ? candidate.indexOf('<!--') + 4 : 0;
+            if (candidate.indexOf('-->', from) !== -1) {
+                this.i = j + 1;
+                return;
+            }
+        }
+        this.sink.report('md-comment-unclosed', 'This comment never closes; the rest of the slide was dropped.', this.src(line, line.text.indexOf('<!--') + 1), [], 'Close the comment with `-->`.');
+        this.i = this.lines.length;
+    }
+    attach(target, attrs) {
+        if (target.attrs) {
+            target.attrs.list.push(...attrs.list);
+            return;
+        }
+        target.attrs = attrs;
+    }
+    /** Take a trailing element comment off the current line's text. */
+    stripTrailing(line) {
+        const tail = trailingElement(line.text);
+        if (!tail)
+            return { text: line.text };
+        return { text: tail.text, attrs: this.elementAttrs(tail.attrs, line.n, tail.column) };
+    }
+    block(depth) {
+        const line = this.lines[this.i];
+        const text = line.text;
+        const fence = FENCE.exec(text);
+        if (fence && !((fence[2] ?? '').startsWith('`') && (fence[3] ?? '').includes('`'))) {
+            return this.code(line, fence[1]?.length ?? 0, fence[2] ?? '```', fence[3] ?? '');
+        }
+        const mathLine = MATH_LINE.exec(trimBlankEnd(text));
+        if (mathLine) {
+            this.i++;
+            return { kind: 'math', tex: (mathLine[1] ?? '').trim(), src: this.src(line) };
+        }
+        if (MATH_OPEN.test(text))
+            return this.math(line);
+        const directive = DIRECTIVE.exec(text);
+        if (directive && /^ {0,3}:::/.test(text)) {
+            return this.directive(line, directive[1] ?? '', directive[2] ?? '', depth);
+        }
+        const { text: content, attrs } = this.stripTrailing(line);
+        const heading = HEADING.exec(trimBlankEnd(content));
+        if (heading) {
+            this.i++;
+            const value = heading[2] ?? '';
+            const node = {
+                kind: 'heading',
+                level: (heading[1] ?? '#').length,
+                text: this.inline(value, line, content.indexOf(value) + 1),
+                src: this.src(line),
+            };
+            if (/(?<!\\)(?:\*|_|`|\[)/.test(value)) {
+                this.sink.report('md-heading-inline', 'Headings are plain text: Markdown inside a heading shows literally.', this.src(line), [], 'Remove the emphasis, or escape it with a backslash.');
+            }
+            if (attrs)
+                node.attrs = attrs;
+            return node;
+        }
+        if (RULE.test(content)) {
+            this.i++;
+            const node = { kind: 'rule', src: this.src(line) };
+            if (attrs)
+                node.attrs = attrs;
+            return node;
+        }
+        const image = matchImageLine(content);
+        if (image) {
+            this.i++;
+            const url = image.url;
+            this.checkUrl(url, true, line, content.indexOf('](') + 3);
+            const node = { kind: 'image', alt: image.alt, url, src: this.src(line) };
+            if (image.title !== undefined)
+                node.title = image.title;
+            if (attrs)
+                node.attrs = attrs;
+            return node;
+        }
+        if (QUOTE.test(content))
+            return this.quote();
+        if (BULLET.test(content) || ORDERED.test(content))
+            return this.list();
+        if (TABLE_ROW.test(content) && isAlignRow(this.lines[this.i + 1]?.text ?? '')) {
+            return this.table();
+        }
+        return this.paragraph();
+    }
+    /** True when `text` starts a block other than a paragraph continuation. */
+    startsBlock(text) {
+        return (text.trim() === '' ||
+            FENCE.test(text) ||
+            MATH_OPEN.test(text) ||
+            MATH_LINE.test(trimBlankEnd(text)) ||
+            /^ {0,3}:::/.test(text) ||
+            HEADING.test(trimBlankEnd(text)) ||
+            RULE.test(text) ||
+            QUOTE.test(text) ||
+            BULLET.test(text) ||
+            ORDERED.test(text) ||
+            TABLE_ROW.test(text) ||
+            text.trimStart().startsWith('<!--') ||
+            isHtmlLine(text) ||
+            NOTE.test(text) ||
+            matchImageLine(text) !== null);
+    }
+    paragraph() {
+        const first = this.lines[this.i];
+        const parts = [];
+        let attrs;
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            if (parts.length > 0 && this.startsBlock(line.text))
+                break;
+            const stripped = this.stripTrailing(line);
+            if (stripped.attrs)
+                attrs = stripped.attrs;
+            parts.push(this.inline(stripped.text.trim(), line, line.text.length - line.text.trimStart().length + 1));
+            this.i++;
+            if (stripped.attrs)
+                break;
+        }
+        const node = { kind: 'paragraph', text: parts.join('\n'), src: this.src(first) };
+        if (attrs)
+            node.attrs = attrs;
+        return node;
+    }
+    quote() {
+        const first = this.lines[this.i];
+        const parts = [];
+        let attrs;
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            const stripped = this.stripTrailing(line);
+            const match = QUOTE.exec(stripped.text);
+            if (!match)
+                break;
+            if (stripped.attrs)
+                attrs = stripped.attrs;
+            parts.push(this.inline(match[1] ?? '', line, stripped.text.indexOf('>') + 2));
+            this.i++;
+        }
+        let cite;
+        const last = parts[parts.length - 1] ?? '';
+        const citeMatch = /^(?:—|--|-)[ \t]+(.+)$/.exec(last);
+        if (citeMatch && parts.length > 1) {
+            cite = citeMatch[1];
+            parts.pop();
+            while (parts.length > 0 && (parts[parts.length - 1] ?? '').trim() === '')
+                parts.pop();
+        }
+        const node = { kind: 'quote', text: parts.join('\n'), src: this.src(first) };
+        if (cite !== undefined)
+            node.cite = cite;
+        if (attrs)
+            node.attrs = attrs;
+        return node;
+    }
+    list() {
+        const first = this.lines[this.i];
+        const ordered = ORDERED.test(this.stripTrailing(first).text);
+        const items = [];
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            const stripped = this.stripTrailing(line);
+            const bullet = BULLET.exec(stripped.text);
+            const numbered = ORDERED.exec(stripped.text);
+            const match = ordered ? numbered : bullet;
+            if (!match || RULE.test(stripped.text))
+                break;
+            const content = (ordered ? match[4] : match[3]) ?? '';
+            const markerWidth = match[0].length - content.length;
+            const indent = markerWidth;
+            const body = [this.inline(content, line, markerWidth + 1)];
+            this.i++;
+            // Continuation: indented lines (nested lists, wrapped text), and lazy
+            // lines that start no other block.
+            while (this.i < this.lines.length) {
+                const next = this.lines[this.i].text;
+                if (next.trim() === '') {
+                    const after = this.lines[this.i + 1]?.text ?? '';
+                    if (/^ {2,}\S/.test(after)) {
+                        body.push('');
+                        this.i++;
+                        continue;
+                    }
+                    break;
+                }
+                if (/^ {2,}\S/.test(next) && !DIRECTIVE_CLOSE.test(next)) {
+                    const spaces = next.length - next.trimStart().length;
+                    const cut = Math.min(spaces, markerWidth);
+                    body.push(this.inline(next.slice(cut), this.lines[this.i], cut + 1));
+                    this.i++;
+                    continue;
+                }
+                if (this.startsBlock(next))
+                    break;
+                body.push(this.inline(next.trim(), this.lines[this.i], 1));
+                this.i++;
+            }
+            const item = { text: body.join('\n'), src: this.src(line, indent + 1) };
+            if (stripped.attrs)
+                item.attrs = stripped.attrs;
+            items.push(item);
+        }
+        return { kind: 'list', ordered, items, src: this.src(first) };
+    }
+    table() {
+        const first = this.lines[this.i];
+        const header = splitCells(this.stripTrailing(first).text).map((cell) => this.inline(cell, first, 1));
+        this.i += 2;
+        const rows = [];
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            const stripped = this.stripTrailing(line);
+            if (!TABLE_ROW.test(stripped.text))
+                break;
+            const row = {
+                cells: splitCells(stripped.text).map((cell) => this.inline(cell, line, 1)),
+                src: this.src(line),
+            };
+            if (stripped.attrs)
+                row.attrs = stripped.attrs;
+            rows.push(row);
+            this.i++;
+        }
+        return { kind: 'table', header, rows, src: this.src(first) };
+    }
+    code(line, indent, marker, info) {
+        this.i++;
+        const char = marker[0] ?? '`';
+        const body = [];
+        let closed = false;
+        while (this.i < this.lines.length) {
+            const text = this.lines[this.i].text;
+            const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(text);
+            if (close?.[1] !== undefined && close[1][0] === char && close[1].length >= marker.length) {
+                this.i++;
+                closed = true;
+                break;
+            }
+            const spaces = text.length - text.trimStart().length;
+            body.push(text.slice(Math.min(spaces, indent)));
+            this.i++;
+        }
+        if (!closed) {
+            this.sink.report('md-code-unclosed', 'This code fence never closes; it runs to the end of the slide.', this.src(line, indent + 1), [], `Close it with a ${marker} line.`);
+        }
+        const node = { kind: 'code', code: body.join('\n'), src: this.src(line, indent + 1) };
+        this.codeInfo(node, info, line, indent + marker.length + 1);
+        return node;
+    }
+    codeInfo(node, info, line, column) {
+        let rest = info;
+        let at = column;
+        const skip = () => {
+            const trimmed = rest.replace(/^[ \t]+/, '');
+            at += rest.length - trimmed.length;
+            rest = trimmed;
+        };
+        skip();
+        const lang = /^[^\s[{]+/.exec(rest)?.[0];
+        if (lang !== undefined) {
+            if (LANG.test(lang))
+                node.lang = lang;
+            else {
+                this.sink.report('md-code-info', `"${lang.slice(0, 32)}" is not a language id; it was dropped.`, { line: line.n, column: at }, [], 'Use a lowercase id such as ts, js, py or sql.');
+            }
+            rest = rest.slice(lang.length);
+            at += lang.length;
+            skip();
+        }
+        if (rest.startsWith('[')) {
+            const end = rest.indexOf(']');
+            if (end === -1) {
+                this.sink.report('md-code-steps', 'The `[` of the highlight steps never closes.', {
+                    line: line.n,
+                    column: at,
+                });
+                rest = '';
+            }
+            else {
+                this.codeSteps(node, rest.slice(1, end), line.n, at);
+                rest = rest.slice(end + 1);
+                at += end + 1;
+                skip();
+            }
+        }
+        if (rest.startsWith('{') && rest.trimEnd().endsWith('}')) {
+            const inner = rest.trimEnd().slice(1, -1);
+            node.brace = {
+                list: readAttributes(inner, line.n, at + 1, this.sink, true),
+                src: { line: line.n, column: at },
+            };
+            rest = '';
+        }
+        if (rest.trim() !== '') {
+            this.sink.report('md-code-info', 'Unread text after the code fence language; it was dropped.', { line: line.n, column: at }, [], 'Write ```lang [1-2|4-6] {filename="x.ts"}.');
+        }
+    }
+    codeSteps(node, raw, line, column) {
+        let steps = raw;
+        const offset = /^\s*\d+\s*:/.exec(steps);
+        if (offset) {
+            this.sink.report('md-code-offset-unsupported', 'A `[n: …]` line offset is not supported; it was dropped.', { line, column });
+            steps = steps.slice(offset[0].length);
+        }
+        const parts = steps.split('|').map((part) => part.replace(/\s+/g, ''));
+        if (parts.length > DECK_MARKDOWN_LIMITS.codeSteps) {
+            this.sink.report('md-code-steps', `A code fence has at most ${DECK_MARKDOWN_LIMITS.codeSteps} highlight steps.`, { line, column });
+            return;
+        }
+        for (const part of parts) {
+            if (!LINE_SPEC.test(part)) {
+                this.sink.report('md-code-steps', `"${part.slice(0, 40)}" is not a line range list such as 1-2,4.`, { line, column }, [], 'Write steps as [1-2|4-6|8].');
+                return;
+            }
+        }
+        if (parts.length > 0 && !(parts.length === 1 && parts[0] === ''))
+            node.highlights = parts;
+    }
+    math(line) {
+        this.i++;
+        const body = [];
+        let closed = false;
+        while (this.i < this.lines.length) {
+            const text = this.lines[this.i].text;
+            this.i++;
+            if (MATH_OPEN.test(text)) {
+                closed = true;
+                break;
+            }
+            body.push(text);
+        }
+        if (!closed) {
+            this.sink.report('md-math-unclosed', 'This `$$` block never closes; it runs to the end of the slide.', this.src(line), [], 'Close it with a `$$` line.');
+        }
+        return { kind: 'math', tex: body.join('\n').trim(), src: this.src(line) };
+    }
+    directive(line, name, rest, depth) {
+        const column = line.text.indexOf(':::') + 1;
+        const src = this.src(line, column);
+        this.i++;
+        let tail = rest.trim();
+        let brace;
+        const braceAt = tail.indexOf('{');
+        if (braceAt !== -1 && tail.endsWith('}')) {
+            const inner = tail.slice(braceAt + 1, -1);
+            const innerColumn = line.text.indexOf('{', column) + 2;
+            brace = {
+                list: readAttributes(inner, line.n, innerColumn, this.sink, true),
+                src: { line: line.n, column: innerColumn - 1 },
+            };
+            tail = tail.slice(0, braceAt).trim();
+        }
+        const node = { kind: 'directive', name, src };
+        if (tail !== '')
+            node.arg = tail;
+        if (brace)
+            node.brace = brace;
+        if (JSON_DIRECTIVES.has(name)) {
+            const body = [];
+            let closed = false;
+            const bodyLine = this.lines[this.i]?.n ?? line.n + 1;
+            while (this.i < this.lines.length) {
+                const text = this.lines[this.i].text;
+                this.i++;
+                if (DIRECTIVE_CLOSE.test(text)) {
+                    closed = true;
+                    break;
+                }
+                body.push(text);
+            }
+            if (!closed)
+                this.unclosed(name, src);
+            node.body = body.join('\n');
+            node.bodyLine = bodyLine;
+            return node;
+        }
+        if (REGION_DIRECTIVES.has(name)) {
+            if (depth + 1 >= DECK_MARKDOWN_LIMITS.directiveDepth) {
+                this.sink.report('md-directive-depth', 'A region cannot hold another region.', src, [], 'Close the outer region first; regions only hold Markdown and JSON fences.');
+            }
+            const inner = this.nodes(depth + 1, true);
+            if (!inner.closed)
+                this.unclosed(name, src);
+            node.children = inner.nodes;
+            return node;
+        }
+        this.sink.report('md-region-unknown', name === ''
+            ? 'A `:::` directive needs a name.'
+            : `Unknown directive "::: ${name.slice(0, 32)}".`, src, [], 'Use a region (left, right, card, video) or a fence (component, block, chart, custom, props, slide).');
+        // Skip to its closer so its body is not read as slide content.
+        while (this.i < this.lines.length) {
+            const text = this.lines[this.i].text;
+            this.i++;
+            if (DIRECTIVE_CLOSE.test(text))
+                break;
+        }
+        return node;
+    }
+    unclosed(name, src) {
+        this.sink.report('md-region-unclosed', `"::: ${name}" never closes before the end of the slide.`, src, [], 'Close it with a `:::` line.');
+    }
+    /**
+     * Check inline Markdown: raw HTML tags (outside code spans) are reported and
+     * escaped so they stay text; link and image URLs get the syntax check;
+     * images inside text are flagged (they render as alt text).
+     */
+    inline(text, line, column) {
+        if (!text.includes('<') && !text.includes(']('))
+            return text;
+        let out = '';
+        let i = 0;
+        let start = 0;
+        // A run length with no closer, or a missing `)`, stays missing further on:
+        // remembering it keeps the scan linear on hostile input.
+        const unmatched = new Set();
+        let lastBracket = -1;
+        while (i < text.length) {
+            const c = text[i];
+            if (c === '`') {
+                let run = 1;
+                while (text[i + run] === '`')
+                    run++;
+                const close = unmatched.has(run) ? -1 : text.indexOf('`'.repeat(run), i + run);
+                if (close === -1)
+                    unmatched.add(run);
+                i = close === -1 ? i + run : close + run;
+                continue;
+            }
+            if (c === '\\') {
+                i += 2;
+                continue;
+            }
+            if (c === '<' && /[A-Za-z/!?]/.test(text[i + 1] ?? '')) {
+                const auto = /^<(?:https?:\/\/|mailto:)[^\s<>]*>/i.exec(text.slice(i, i + 2100));
+                if (auto) {
+                    this.checkUrl(auto[0].slice(1, -1), false, line, column + i + 1);
+                    i += auto[0].length;
+                    continue;
+                }
+                const iframe = /^<\/?iframe\b/i.test(text.slice(i, i + 8));
+                this.sink.report(iframe ? 'md-iframe-refused' : 'md-html-refused', iframe ? 'iframes are refused.' : 'Inline HTML is refused; the tag stays literal text.', { line: line.n, column: column + i }, [], 'Use Markdown emphasis, links and code instead of tags.');
+                out += `${text.slice(start, i)}\\<`;
+                i++;
+                start = i;
+                continue;
+            }
+            if (c === ']' && text[i + 1] === '(') {
+                // The destination: up to whitespace, `)` or `>` (each character read once).
+                let j = i + 2;
+                while (text[j] === ' ' || text[j] === '<')
+                    j++;
+                const from = j;
+                while (j < text.length && j - from < 2100 && !/[\s)<>]/.test(text[j] ?? ''))
+                    j++;
+                const url = text.slice(from, j);
+                const isImage = lastBracket > 0 && text[lastBracket - 1] === '!';
+                if (isImage) {
+                    this.sink.report('md-inline-image', 'An image inside text renders as its alt text only.', { line: line.n, column: column + lastBracket - 1 }, [], 'Put the image on its own line.');
+                }
+                this.checkUrl(url, isImage, line, column + from);
+                i = Math.max(j, i + 2);
+                continue;
+            }
+            if (c === '[')
+                lastBracket = i;
+            i++;
+        }
+        return start === 0 ? text : out + text.slice(start);
+    }
+    checkUrl(url, media, line, column) {
+        if (url === '')
+            return;
+        const ok = media ? MEDIA_SRC.test(url) : LINK_HREF.test(url);
+        if (ok)
+            return;
+        this.sink.report('md-url-refused', media
+            ? 'Media must be an https: URL, a relative path (no .. or .svg), a base64 data: raster or video, or an avatar: id.'
+            : 'Links must be https:, mailto:, a #fragment or a relative path.', { line: line.n, column }, [], 'Use an allowed URL; javascript:, data:text/html and protocol-relative URLs are refused.');
+    }
+}
+/** Split a pipe-table row into trimmed cells (`\|` stays inside a cell). */
+export function splitCells(row) {
+    let text = row.trim();
+    if (text.startsWith('|'))
+        text = text.slice(1);
+    if (text.endsWith('|') && !text.endsWith('\\|'))
+        text = text.slice(0, -1);
+    const cells = [];
+    let current = '';
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '\\' && text[i + 1] === '|') {
+            current += '\\|';
+            i++;
+        }
+        else if (c === '|') {
+            cells.push(current.trim());
+            current = '';
+        }
+        else
+            current += c;
+    }
+    cells.push(current.trim());
+    return cells;
+}
+/** Read one slide's lines into nodes, slide attributes and notes. */
+export function readSlide(lines, sink) {
+    const reader = new Reader(lines, sink);
+    const { nodes } = reader.nodes(0, false);
+    const out = { nodes, slideAttrs: reader.slideAttrs };
+    if (reader.notes)
+        out.notes = reader.notes;
+    return out;
+}