@texuli/core 0.1.0-next.0 → 0.1.0-next.1

package/dist/editor/markdown.js

@@ -0,0 +1,705 @@
+import { normalizeDocument, paragraph } from "./document.js";
+import { markKey, normalizeInline, sortMarks } from "./inline.js";
+import { LoadBudget } from "./load.js";
+/**
+ * The editor's Markdown codec (ADR-003): the same closed subset that
+ * `@texuli/blocks` text blocks and the catalog's rich text parse, read into
+ * and written from the editor model. Nothing here produces or keeps HTML: raw
+ * tags stay literal text, every link passes `safeHref`, and images become
+ * their alt text (or a media block when one stands alone in a paragraph).
+ */
+export const MARKDOWN_CODEC_LIMITS = Object.freeze({
+    /** Longest source read; the rest is dropped with a diagnostic. */
+    source: 100_000,
+    /** Nested emphasis and links. */
+    inlineDepth: 6,
+});
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([a-z][a-z0-9+-]{0,31})?\s*$/i;
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*#*[ \t]*$/;
+const RULE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+const QUOTE = /^ {0,3}> ?(.*)$/;
+const BULLET = /^( {0,3})([-*+])[ \t]+(.*)$/;
+const ORDERED = /^( {0,3})(\d{1,9})[.)][ \t]+(.*)$/;
+const TASK = /^\[([ xX])\][ \t]+/;
+const IMAGE_ONLY = /^!\[((?:[^\]\\\n]|\\.)*)\]\(\s*<?([^\s()<>]+)>?\s*\)$/;
+const ESCAPABLE = /[\\`*_{}[\]()#+\-.!~<>|]/;
+const isBlank = (line) => line.trim() === '';
+function listMarker(line) {
+    const bullet = BULLET.exec(line);
+    if (bullet)
+        return { ordered: false, start: 1, content: bullet[3] ?? '' };
+    const ordered = ORDERED.exec(line);
+    if (ordered)
+        return { ordered: true, start: Number(ordered[2]), content: ordered[3] ?? '' };
+    return null;
+}
+const startsBlock = (line) => FENCE.test(line) ||
+    HEADING.test(line) ||
+    RULE.test(line) ||
+    QUOTE.test(line) ||
+    listMarker(line) !== null;
+/**
+ * Read Markdown (untrusted by default) into a valid document. Never throws:
+ * nesting deeper than the depth cap and oversized input degrade to text,
+ * refused links keep their text, headings deeper than 4 become level 4, and
+ * each degradation is reported once in `diagnostics`.
+ */
+export function fromMarkdown(source, options = {}) {
+    const budget = new LoadBudget(options);
+    const max = options.maxSource ?? MARKDOWN_CODEC_LIMITS.source;
+    let text = (typeof source === 'string' ? source : String(source ?? '')).replace(/\r\n?/g, '\n');
+    if (text.length > max) {
+        budget.report('text-truncated', `Markdown after ${max} characters was dropped.`);
+        text = text.slice(0, max);
+    }
+    const reader = new Reader(budget);
+    const blocks = reader.blocks(text.split('\n'), 0);
+    return {
+        doc: normalizeDocument({ version: 1, blocks }, budget.newId),
+        diagnostics: budget.diagnostics,
+    };
+}
+class Reader {
+    budget;
+    constructor(budget) {
+        this.budget = budget;
+    }
+    blocks(lines, depth) {
+        const out = [];
+        const push = (make) => {
+            if (!this.budget.block())
+                return;
+            const block = make();
+            if (block)
+                out.push(block);
+        };
+        let i = 0;
+        while (i < lines.length) {
+            if (this.budget.blocks >= this.budget.limits.blocks) {
+                this.budget.block();
+                break;
+            }
+            const line = lines[i] ?? '';
+            if (isBlank(line)) {
+                i += 1;
+                continue;
+            }
+            const fence = FENCE.exec(line);
+            if (fence) {
+                const marker = fence[1] ?? '```';
+                const body = [];
+                i += 1;
+                while (i < lines.length && !(lines[i] ?? '').trim().startsWith(marker)) {
+                    body.push(lines[i] ?? '');
+                    i += 1;
+                }
+                i += 1;
+                const lang = fence[2]?.toLowerCase();
+                push(() => {
+                    const code = this.budget.text(this.budget.clean(body.join('\n'), '\n\t'));
+                    return lang
+                        ? { id: this.budget.newId(), type: 'code', lang, text: code }
+                        : { id: this.budget.newId(), type: 'code', text: code };
+                });
+                continue;
+            }
+            const heading = HEADING.exec(line);
+            if (heading) {
+                const level = (heading[1] ?? '#').length;
+                if (level > 4)
+                    this.budget.report('heading-clamped', 'Headings deeper than level 4 became level 4.');
+                push(() => ({
+                    id: this.budget.newId(),
+                    type: 'heading',
+                    level: Math.min(level, 4),
+                    content: trimEdges(this.inline((heading[2] ?? '').trim())),
+                }));
+                i += 1;
+                continue;
+            }
+            if (RULE.test(line)) {
+                push(() => ({ id: this.budget.newId(), type: 'divider' }));
+                i += 1;
+                continue;
+            }
+            if (QUOTE.test(line)) {
+                const inner = [];
+                while (i < lines.length && QUOTE.test(lines[i] ?? '')) {
+                    inner.push(QUOTE.exec(lines[i] ?? '')?.[1] ?? '');
+                    i += 1;
+                }
+                if (depth < this.budget.limits.depth) {
+                    push(() => {
+                        const blocks = this.blocks(inner, depth + 1);
+                        return blocks.length ? { id: this.budget.newId(), type: 'quote', blocks } : null;
+                    });
+                }
+                else {
+                    this.budget.report('depth-capped', 'Lists and quotes nested past the depth cap became text.');
+                    push(() => this.paragraph(inner.join('\n')));
+                }
+                continue;
+            }
+            const marker = listMarker(line);
+            if (marker) {
+                const parsed = this.list(lines, i, marker.ordered, marker.start, depth);
+                if (parsed.block)
+                    out.push(parsed.block);
+                i = parsed.next;
+                continue;
+            }
+            const lines_ = [line];
+            i += 1;
+            while (i < lines.length && !isBlank(lines[i] ?? '') && !startsBlock(lines[i] ?? '')) {
+                lines_.push(lines[i] ?? '');
+                i += 1;
+            }
+            push(() => {
+                // An empty paragraph (a blank link label, say) cannot be written back: drop it.
+                const block = this.paragraph(lines_.join('\n'));
+                return block.type === 'paragraph' && block.content.length === 0 ? null : block;
+            });
+        }
+        return out;
+    }
+    paragraph(source) {
+        const trimmed = source.trim();
+        const image = IMAGE_ONLY.exec(trimmed);
+        if (image?.[2]) {
+            const alt = this.budget.text(this.budget.clean(unescapeMarkdown(image[1] ?? ''), ''));
+            return { id: this.budget.newId(), type: 'media', ref: image[2], alt };
+        }
+        return paragraph(trimEdges(this.inline(trimmed)), this.budget.newId());
+    }
+    list(lines, from, ordered, start, depth) {
+        const raw = [];
+        let i = from;
+        while (i < lines.length) {
+            const marker = listMarker(lines[i] ?? '');
+            if (!marker || marker.ordered !== ordered)
+                break;
+            const body = [marker.content];
+            i += 1;
+            while (i < lines.length) {
+                const next = lines[i] ?? '';
+                if (isBlank(next)) {
+                    if (/^ {2,}\S/.test(lines[i + 1] ?? '')) {
+                        body.push('');
+                        i += 1;
+                        continue;
+                    }
+                    break;
+                }
+                if (/^ {2,}\S/.test(next)) {
+                    body.push(next.replace(/^ {2,4}/, ''));
+                    i += 1;
+                    continue;
+                }
+                if (startsBlock(next))
+                    break;
+                body.push(next);
+                i += 1;
+            }
+            let checked = null;
+            const task = TASK.exec(body[0] ?? '');
+            if (task) {
+                checked = task[1] !== ' ';
+                body[0] = (body[0] ?? '').slice(task[0].length);
+            }
+            raw.push({ checked, body });
+        }
+        if (!this.budget.block())
+            return { block: null, next: i };
+        if (depth >= this.budget.limits.depth) {
+            this.budget.report('depth-capped', 'Lists and quotes nested past the depth cap became text.');
+            return { block: this.paragraph(raw.map((item) => item.body.join(' ')).join('\n')), next: i };
+        }
+        const todo = raw.some((item) => item.checked !== null);
+        const kind = todo ? 'todo' : ordered ? 'ordered' : 'bullet';
+        const items = [];
+        for (const item of raw) {
+            if (!this.budget.block())
+                break;
+            const read = this.blocks(item.body, depth + 1);
+            // An empty first block followed by others cannot be written back: the next block leads.
+            while (read.length > 1 && isEmptyText(read[0]))
+                read.shift();
+            const blocks = read.length ? read : [paragraph([], this.budget.newId())];
+            items.push(todo
+                ? { id: this.budget.newId(), checked: item.checked === true, blocks }
+                : { id: this.budget.newId(), blocks });
+        }
+        const id = this.budget.newId();
+        const block = kind === 'ordered' && start !== 1
+            ? { id, type: 'list', kind, start, items }
+            : { id, type: 'list', kind, items };
+        return { block, next: i };
+    }
+    inline(source) {
+        const out = [];
+        parseInline(source, 0, [], false, out, this.budget);
+        // Canonical like the writer: marks never start or end on whitespace.
+        return prepareMarks(normalizeInline(out));
+    }
+}
+const isEmptyText = (block) => (block.type === 'paragraph' || block.type === 'heading') && block.content.length === 0;
+const unescapeMarkdown = (text) => text.replace(/\\([\\`*_{}[\]()#+\-.!~<>|])/g, '$1');
+/**
+ * Closers and bracket pairs of one inline source, computed once so that each
+ * lookup is constant time: hostile delimiter runs stay linear. The answers
+ * equal a left-to-right search from each opener.
+ */
+class Scan {
+    source;
+    closers = new Map();
+    brackets = null;
+    constructor(source) {
+        this.source = source;
+    }
+    /** The first valid closer of `marker` at or after `from`, or -1. */
+    closer(marker, from) {
+        let table = this.closers.get(marker);
+        if (!table) {
+            table = this.build(marker);
+            this.closers.set(marker, table);
+        }
+        const { at, first } = table;
+        let low = 0;
+        let high = at.length;
+        while (low < high) {
+            const mid = (low + high) >> 1;
+            if (at[mid] < from)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        return low < at.length ? first[low] : -1;
+    }
+    build(marker) {
+        const { source } = this;
+        const at = [];
+        for (let j = source.indexOf(marker); j !== -1; j = source.indexOf(marker, j + 1))
+            at.push(j);
+        const index = new Map(at.map((position, i) => [position, i]));
+        const first = new Int32Array(at.length).fill(-1);
+        for (let i = at.length - 1; i >= 0; i -= 1) {
+            const close = at[i];
+            const before = source[close - 1] ?? '';
+            const after = source[close + marker.length] ?? '';
+            const doubled = marker.length === 1 && after === marker;
+            const midWord = marker[0] === '_' && /[\p{L}\p{N}]/u.test(after);
+            if (!/\s/.test(before) && before !== '\\' && !doubled && !midWord) {
+                first[i] = close;
+                continue;
+            }
+            // The search resumes one past this candidate (two past a doubled one).
+            const resume = close + (doubled ? 2 : 1);
+            let next = index.get(resume);
+            if (next === undefined) {
+                next = i + 1;
+                while (next < at.length && at[next] < resume)
+                    next += 1;
+            }
+            first[i] = next < at.length ? first[next] : -1;
+        }
+        return { at, first };
+    }
+    /** The `]` closing the `[` at `open` (nesting and escapes respected), or -1. */
+    bracket(open) {
+        if (!this.brackets) {
+            const { source } = this;
+            const pairs = new Int32Array(source.length).fill(-1);
+            const stack = [];
+            for (let j = 0; j < source.length; j += 1) {
+                const c = source[j];
+                if (c === '\\')
+                    j += 1;
+                else if (c === '[')
+                    stack.push(j);
+                else if (c === ']' && stack.length)
+                    pairs[stack.pop()] = j;
+            }
+            this.brackets = pairs;
+        }
+        return this.brackets[open] ?? -1;
+    }
+}
+/** Inline Markdown into runs; `marks` are the marks open around `source`. */
+function parseInline(source, depth, marks, inLink, out, budget) {
+    let buffer = '';
+    const flush = () => {
+        if (buffer)
+            out.push(...budget.inline(buffer.replace(/\n/g, ' '), marks));
+        buffer = '';
+    };
+    const push = (text, extra) => {
+        flush();
+        out.push(...budget.inline(text, sortMarks([...marks, ...extra])));
+    };
+    const scan = new Scan(source);
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i] ?? '';
+        if (ch === '\\') {
+            const next = source[i + 1] ?? '';
+            if (next === '\n') {
+                flush();
+                out.push({ type: 'break' });
+                budget.chars += 1;
+                i += 2;
+                continue;
+            }
+            if (ESCAPABLE.test(next)) {
+                buffer += next;
+                i += 2;
+                continue;
+            }
+        }
+        if (ch === '\n') {
+            if (/ {2,}$/.test(buffer)) {
+                buffer = buffer.replace(/ +$/, '');
+                flush();
+                out.push({ type: 'break' });
+                budget.chars += 1;
+            }
+            else
+                buffer += '\n';
+            i += 1;
+            continue;
+        }
+        if (ch === '`') {
+            const run = /^`+/.exec(source.slice(i, i + 64))?.[0] ?? '`';
+            const close = source.indexOf(run, i + run.length);
+            if (close !== -1) {
+                const code = source.slice(i + run.length, close).replace(/\n/g, ' ');
+                push(code.length > 2 && /^ .* $/.test(code) ? code.slice(1, -1) : code, [{ type: 'code' }]);
+                i = close + run.length;
+                continue;
+            }
+            buffer += run;
+            i += run.length;
+            continue;
+        }
+        if (depth < MARKDOWN_CODEC_LIMITS.inlineDepth) {
+            const emphasis = matchEmphasis(scan, i);
+            if (emphasis) {
+                flush();
+                const mark = { type: emphasis.type };
+                parseInline(source.slice(emphasis.innerStart, emphasis.innerEnd), depth + 1, sortMarks([...marks, mark]), inLink, out, budget);
+                i = emphasis.end;
+                continue;
+            }
+            if (ch === '!' && source[i + 1] === '[') {
+                const image = matchLink(scan, i + 1);
+                if (image) {
+                    buffer += unescapeMarkdown(source.slice(image.labelStart, image.labelEnd));
+                    i = image.end;
+                    continue;
+                }
+            }
+            if (ch === '[' && !inLink) {
+                const link = matchLink(scan, i);
+                if (link) {
+                    flush();
+                    const href = budget.href(link.href);
+                    const inner = href ? sortMarks([...marks, { type: 'link', href }]) : marks;
+                    parseInline(source.slice(link.labelStart, link.labelEnd), depth + 1, inner, true, out, budget);
+                    i = link.end;
+                    continue;
+                }
+            }
+            if (ch === '<' && !inLink) {
+                const auto = /^<((?:https?:\/\/|mailto:)[^\s<>]+)>/i.exec(source.slice(i, i + 2_100));
+                if (auto?.[1]) {
+                    const href = budget.href(auto[1]);
+                    push(auto[1], href ? [{ type: 'link', href }] : []);
+                    i += auto[0].length;
+                    continue;
+                }
+            }
+        }
+        buffer += ch;
+        i += 1;
+    }
+    flush();
+}
+function matchEmphasis(scan, at) {
+    const { source } = scan;
+    const candidates = [
+        { marker: '**', type: 'strong' },
+        { marker: '__', type: 'strong' },
+        { marker: '~~', type: 'strike' },
+        { marker: '*', type: 'em' },
+        { marker: '_', type: 'em' },
+    ];
+    for (const { marker, type } of candidates) {
+        if (!source.startsWith(marker, at))
+            continue;
+        const innerStart = at + marker.length;
+        const first = source[innerStart] ?? '';
+        if (first === '' || /\s/.test(first))
+            continue;
+        if (marker[0] === '_' && /[\p{L}\p{N}]/u.test(source[at - 1] ?? ''))
+            continue;
+        const close = scan.closer(marker, innerStart + 1);
+        if (close === -1)
+            continue;
+        return { type, innerStart, innerEnd: close, end: close + marker.length };
+    }
+    return null;
+}
+function matchLink(scan, at) {
+    const { source } = scan;
+    const labelEnd = scan.bracket(at);
+    if (labelEnd === -1 || source[labelEnd + 1] !== '(')
+        return null;
+    const target = /^\(\s*<?((?:[^\s()<>]|\([^\s()<>]*\))*)>?(?:\s+"[^"\n]*")?\s*\)/.exec(source.slice(labelEnd + 1, labelEnd + 1 + 2_100));
+    if (!target)
+        return null;
+    return {
+        labelStart: at + 1,
+        labelEnd,
+        href: target[1] ?? '',
+        end: labelEnd + 1 + target[0].length,
+    };
+}
+// ---------------------------------------------------------------------------
+// Writing
+const escapeText = (text) => text.replace(/[\\`*_[\]~<!]/g, '\\$&');
+/** A line that would start another block gets its first marker escaped. */
+function escapeLineStart(line) {
+    const ordered = /^( {0,3}\d{1,9})([.)])([ \t]|$)/.exec(line);
+    if (ordered)
+        return `${ordered[1]}\\${ordered[2]}${line.slice(ordered[1].length + 1)}`;
+    if (startsBlock(line)) {
+        return line.replace(/^( {0,3})(\S)/, '$1\\$2');
+    }
+    return line;
+}
+const encodeRef = (href) => href.replace(/[\s()<>]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`);
+function codeSpan(text) {
+    const longest = Math.max(0, ...[...text.matchAll(/`+/g)].map((m) => m[0].length));
+    const fence = '`'.repeat(longest + 1);
+    const pad = text.startsWith('`') || text.endsWith('`') || /^ .* $/.test(text) ? ' ' : '';
+    return `${fence}${pad}${text}${pad}${fence}`;
+}
+/** Move whitespace and trailing backslashes out of strong, em and strike spans (Markdown cannot open or close there). */
+function prepareMarks(content) {
+    const chars = [];
+    for (const node of content) {
+        if (node.type === 'break')
+            chars.push(null);
+        else
+            for (const ch of node.text)
+                chars.push({ ch, marks: node.marks });
+    }
+    for (const type of ['strong', 'em', 'strike']) {
+        let i = 0;
+        const marked = (c) => c?.marks.some((m) => m.type === type) === true;
+        // A break inside a span (marked text on both sides) does not end it.
+        const has = (k) => {
+            if (chars[k] !== null)
+                return marked(chars[k]);
+            let left = k - 1;
+            while (chars[left] === null)
+                left -= 1;
+            let right = k + 1;
+            while (chars[right] === null)
+                right += 1;
+            return left >= 0 && marked(chars[left]) && marked(chars[right]);
+        };
+        while (i < chars.length) {
+            if (!has(i)) {
+                i += 1;
+                continue;
+            }
+            let end = i;
+            while (has(end + 1))
+                end += 1;
+            const drop = (k) => {
+                const c = chars[k];
+                chars[k] = { ch: c.ch, marks: c.marks.filter((m) => m.type !== type) };
+            };
+            let a = i;
+            while (a <= end && chars[a] && /\s/.test(chars[a].ch))
+                drop(a++);
+            let b = end;
+            while (b >= a && chars[b] && /[\s\\]/.test(chars[b].ch))
+                drop(b--);
+            i = end + 1;
+        }
+    }
+    const out = [];
+    for (const c of chars)
+        out.push(c ? { type: 'text', text: c.ch, marks: c.marks } : { type: 'break' });
+    return normalizeInline(out);
+}
+function writeInline(content, em) {
+    const open = { strong: '**', em, strike: '~~' };
+    const texts = content.flatMap((node, index) => (node.type === 'text' ? [{ node, index }] : []));
+    const stack = [];
+    const outer = (marks) => marks.filter((m) => m.type !== 'code');
+    /** Where the span of `mark` starting at text `t` ends (marks that end later nest outside). */
+    const spanEnd = (t, mark) => {
+        let end = t;
+        while (texts[end + 1]?.node.marks.some((m) => markKey(m) === markKey(mark)))
+            end += 1;
+        return end;
+    };
+    const ordered = (t) => {
+        const marks = outer(texts[t].node.marks);
+        const opened = (mark) => {
+            const at = stack.findIndex((open) => markKey(open) === markKey(mark));
+            return at === -1 ? Number.POSITIVE_INFINITY : at;
+        };
+        // Later-ending marks nest outside; on a tie, a mark already open stays outside.
+        return marks
+            .map((mark, rank) => ({ mark, rank, end: spanEnd(t, mark), open: opened(mark) }))
+            .sort((a, b) => b.end - a.end || a.open - b.open || a.rank - b.rank)
+            .map(({ mark }) => mark);
+    };
+    let out = '';
+    const close = (to) => {
+        while (stack.length > to) {
+            const mark = stack.pop();
+            out += mark.type === 'link' ? `](${encodeRef(mark.href)})` : open[mark.type];
+        }
+    };
+    const keepCommon = (wanted) => {
+        let common = 0;
+        while (common < stack.length &&
+            common < wanted.length &&
+            markKey(stack[common]) === markKey(wanted[common]))
+            common += 1;
+        close(common);
+        return common;
+    };
+    let t = 0;
+    content.forEach((node, index) => {
+        if (node.type === 'break') {
+            // Marks the next text keeps stay open across the break.
+            const next = texts.findIndex((entry) => entry.index > index);
+            keepCommon(next === -1 ? [] : ordered(next).filter((m) => stack.some((s) => markKey(s) === markKey(m))));
+            out += '\\\n';
+            return;
+        }
+        const wanted = ordered(t);
+        const common = keepCommon(wanted);
+        for (const mark of wanted.slice(common)) {
+            out += mark.type === 'link' ? '[' : open[mark.type];
+            stack.push(mark);
+        }
+        out += node.marks.some((m) => m.type === 'code') ? codeSpan(node.text) : escapeText(node.text);
+        t += 1;
+    });
+    close(0);
+    return out;
+}
+const sameInline = (a, b) => a.length === b.length &&
+    a.every((node, i) => {
+        const other = b[i];
+        if (node.type === 'break' || other.type === 'break')
+            return node.type === other.type;
+        return (node.text === other.text && node.marks.map(markKey).join() === other.marks.map(markKey).join());
+    });
+/** Read inline Markdown back without caps or policy changes (for the write check). */
+function reread(markdown) {
+    const budget = new LoadBudget({ trust: 'developer' });
+    const out = [];
+    parseInline(markdown, 0, [], false, out, budget);
+    return normalizeInline(out);
+}
+/**
+ * Inline content as Markdown that reads back to the same runs. When a mark
+ * combination has no faithful spelling in the subset, the result drops the
+ * least significant marks (em, then strike, then strong) until it does.
+ */
+function inlineMarkdown(content, lineStart) {
+    let prepared = prepareMarks(content);
+    const attempt = (em) => {
+        const text = writeInline(prepared, em).split('\n').map(lineStart).join('\n');
+        return sameInline(reread(text), prepared) ? text : null;
+    };
+    for (const drop of [null, 'em', 'strike', 'strong']) {
+        if (drop)
+            prepared = normalizeInline(prepared.map((n) => n.type === 'text' ? { ...n, marks: n.marks.filter((m) => m.type !== drop) } : n));
+        const text = attempt('*') ?? attempt('_');
+        if (text !== null)
+            return text;
+    }
+    return writeInline(prepared, '*').split('\n').map(lineStart).join('\n');
+}
+const indent = (text, by) => text
+    .split('\n')
+    .map((line) => (line ? by + line : line))
+    .join('\n');
+function writeBlocks(blocks) {
+    return blocks
+        .map(writeBlock)
+        .filter((text) => text !== '')
+        .join('\n\n');
+}
+function writeBlock(block) {
+    switch (block.type) {
+        case 'paragraph':
+            return inlineMarkdown(trimEdges(block.content), escapeLineStart);
+        case 'heading': {
+            const flat = block.content.map((n) => (n.type === 'break' ? { type: 'text', text: ' ', marks: [] } : n));
+            const text = inlineMarkdown(trimEdges(normalizeInline(flat)), (line) => line);
+            return `${'#'.repeat(block.level)}${text ? ` ${text}` : ''}${text.endsWith('#') ? ' #' : ''}`;
+        }
+        case 'code': {
+            const longest = Math.max(2, ...[...block.text.matchAll(/^[ \t]*(`+)/gm)].map((m) => m[1].length));
+            const fence = '`'.repeat(longest + 1);
+            return `${fence}${block.lang ?? ''}\n${block.text}${block.text ? '\n' : ''}${fence}`;
+        }
+        case 'list':
+            return block.items
+                .map((item, i) => {
+                const marker = block.kind === 'ordered'
+                    ? `${(block.start ?? 1) + i}. `
+                    : block.kind === 'todo'
+                        ? `- [${item.checked ? 'x' : ' '}] `
+                        : '- ';
+                const [first, ...rest] = item.blocks;
+                const head = first ? indent(writeBlock(first), '    ').trimStart() : '';
+                const tail = writeBlocks(rest);
+                return `${marker}${head}${tail ? `\n\n${indent(tail, '    ')}` : ''}`;
+            })
+                .join('\n');
+        case 'quote':
+            return writeBlocks(block.blocks)
+                .split('\n')
+                .map((line) => (line ? `> ${line}` : '>'))
+                .join('\n');
+        case 'divider':
+            return '---';
+        case 'media':
+            return `![${escapeText(block.alt)}](${encodeRef(block.ref)})`;
+    }
+}
+/** Paragraph edges are trimmed when read, so they are trimmed when written. */
+function trimEdges(content) {
+    const out = [...content];
+    while (out[0]?.type === 'break')
+        out.shift();
+    while (out.at(-1)?.type === 'break')
+        out.pop();
+    const plain = (node) => node?.type === 'text' && !node.marks.some((mark) => mark.type === 'code');
+    const first = out[0];
+    if (plain(first))
+        out[0] = { ...first, text: first.text.trimStart() };
+    const last = out.at(-1);
+    if (plain(last))
+        out[out.length - 1] = { ...last, text: last.text.trimEnd() };
+    return normalizeInline(out);
+}
+/**
+ * Write a document as the closed Markdown subset. Reading the result back
+ * gives the same document, except for what the subset cannot spell: empty
+ * paragraphs, breaks in headings (written as spaces), breaks at the edges of
+ * a block, and whitespace at the edges of a paragraph or a mark.
+ */
+export function toMarkdown(doc) {
+    return writeBlocks(doc.blocks);
+}