@texuli/core 0.4.0 → 0.6.0

package/dist/editor/markdown.js

@@ -1,4 +1,5 @@
 import { normalizeDocument, paragraph } from "./document.js";
+import { acceptsExtensionId, EDITOR_EXTENSION_LIMITS, isExtensionIdChar, toInlineExtensions, } from "./extensions.js";
 import { markKey, normalizeInline, sortMarks } from "./inline.js";
 import { LoadBudget } from "./load.js";
 /**
@@ -14,16 +15,62 @@ export const MARKDOWN_CODEC_LIMITS = Object.freeze({
     /** 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]*$/;
+// Line patterns stay linear on hostile lines: no two neighboring quantifiers
+// can match the same characters, and `.` uses the `s` flag so U+2028 and
+// U+2029 inside a line never make a `(.*)$` tail backtrack. The fence info
+// string and the heading closing sequence are read by hand (their regex
+// forms backtracked quadratically, and cubically, on runs of spaces).
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+const FENCE_LANG = /^[a-z][a-z0-9+-]{0,31}$/i;
+const HEADING_OPEN = /^ {0,3}(#+)/;
 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 QUOTE = /^ {0,3}> ?(.*)$/s;
+const BULLET = /^( {0,3})([-*+])[ \t]+(.*)$/s;
+const ORDERED = /^( {0,3})(\d{1,9})[.)][ \t]+(.*)$/s;
 const TASK = /^\[([ xX])\][ \t]+/;
 const IMAGE_ONLY = /^!\[((?:[^\]\\\n]|\\.)*)\]\(\s*<?([^\s()<>]+)>?\s*\)$/;
 const ESCAPABLE = /[\\`*_{}[\]()#+\-.!~<>|]/;
 const isBlank = (line) => line.trim() === '';
+const isSpace = (char) => char === ' ' || char === '\t';
+/** A fence opening line: its marker and the optional language. */
+function readFence(line) {
+    const open = FENCE_OPEN.exec(line);
+    if (!open)
+        return null;
+    const info = line.slice(open[0].length).trim();
+    if (info !== '' && !FENCE_LANG.test(info))
+        return null;
+    return info
+        ? { marker: open[1], lang: info.toLowerCase() }
+        : { marker: open[1] };
+}
+/**
+ * An ATX heading line: up to 6 `#` (a 7th or later reads as part of the
+ * closing sequence), then text after a space or tab, with the closing
+ * sequence of spaces, `#` and spaces dropped from the end.
+ */
+function readHeading(line) {
+    const open = HEADING_OPEN.exec(line);
+    if (!open)
+        return null;
+    const hashes = open[1];
+    const level = Math.min(hashes.length, 6);
+    const rest = line.slice(open[0].length - hashes.length + level);
+    let start = 0;
+    while (isSpace(rest[start]))
+        start += 1;
+    let end = rest.length;
+    while (end > start && isSpace(rest[end - 1]))
+        end -= 1;
+    while (end > start && rest[end - 1] === '#')
+        end -= 1;
+    while (end > start && isSpace(rest[end - 1]))
+        end -= 1;
+    // Without a space or tab after the opening, only a closing sequence may follow.
+    if (start === 0 && end > 0)
+        return null;
+    return { level, text: rest.slice(start, end) };
+}
 function listMarker(line) {
     const bullet = BULLET.exec(line);
     if (bullet)
@@ -33,8 +80,8 @@ function listMarker(line) {
         return { ordered: true, start: Number(ordered[2]), content: ordered[3] ?? '' };
     return null;
 }
-const startsBlock = (line) => FENCE.test(line) ||
-    HEADING.test(line) ||
+const startsBlock = (line) => readFence(line) !== null ||
+    readHeading(line) !== null ||
     RULE.test(line) ||
     QUOTE.test(line) ||
     listMarker(line) !== null;
@@ -84,9 +131,9 @@ class Reader {
                 i += 1;
                 continue;
             }
-            const fence = FENCE.exec(line);
+            const fence = readFence(line);
             if (fence) {
-                const marker = fence[1] ?? '```';
+                const marker = fence.marker;
                 const body = [];
                 i += 1;
                 while (i < lines.length && !(lines[i] ?? '').trim().startsWith(marker)) {
@@ -94,7 +141,7 @@ class Reader {
                     i += 1;
                 }
                 i += 1;
-                const lang = fence[2]?.toLowerCase();
+                const lang = fence.lang;
                 push(() => {
                     const code = this.budget.text(this.budget.clean(body.join('\n'), '\n\t'));
                     return lang
@@ -103,16 +150,16 @@ class Reader {
                 });
                 continue;
             }
-            const heading = HEADING.exec(line);
+            const heading = readHeading(line);
             if (heading) {
-                const level = (heading[1] ?? '#').length;
+                const level = heading.level;
                 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())),
+                    content: trimEdges(this.inline(heading.text.trim())),
                 }));
                 i += 1;
                 continue;
@@ -253,9 +300,51 @@ class Scan {
     source;
     closers = new Map();
     brackets = null;
+    tokens = null;
     constructor(source) {
         this.source = source;
     }
+    /**
+     * The extension token `<sigil>{id|label}` whose sigil is at `at`, or null.
+     * Two linear passes the first time (the id-character run from each index,
+     * and the next unescaped `}` before a newline), then constant time.
+     */
+    extension(at) {
+        const { source } = this;
+        if (source[at + 1] !== '{')
+            return null;
+        if (!this.tokens) {
+            const n = source.length;
+            const idRun = new Int32Array(n + 1);
+            for (let j = n - 1; j >= 0; j -= 1)
+                idRun[j] = isExtensionIdChar(source.charCodeAt(j)) ? idRun[j + 1] + 1 : 0;
+            const escaped = new Uint8Array(n);
+            for (let j = 0; j < n; j += 1) {
+                if (source[j] === '\\') {
+                    if (j + 1 < n)
+                        escaped[j + 1] = 1;
+                    j += 1;
+                }
+            }
+            const close = new Int32Array(n + 1).fill(-1);
+            for (let j = n - 1; j >= 0; j -= 1) {
+                const c = source[j];
+                close[j] = c === '\n' ? -1 : c === '}' && !escaped[j] ? j : close[j + 1];
+            }
+            this.tokens = { idRun, close };
+        }
+        const idStart = at + 2;
+        const idEnd = idStart + (this.tokens.idRun[idStart] ?? 0);
+        if (idEnd === idStart || idEnd - idStart > EDITOR_EXTENSION_LIMITS.id)
+            return null;
+        if (source[idEnd] !== '|')
+            return null;
+        const labelStart = idEnd + 1;
+        const labelEnd = this.tokens.close[labelStart] ?? -1;
+        if (labelEnd <= labelStart || labelEnd - labelStart > EDITOR_EXTENSION_LIMITS.label)
+            return null;
+        return { idStart, idEnd, labelStart, labelEnd, end: labelEnd + 1 };
+    }
     /** The first valid closer of `marker` at or after `from`, or -1. */
     closer(marker, from) {
         let table = this.closers.get(marker);
@@ -327,16 +416,31 @@ class Scan {
 /** Inline Markdown into runs; `marks` are the marks open around `source`. */
 function parseInline(source, depth, marks, inLink, out, budget) {
     let buffer = '';
+    // Spaces at the end of `buffer`, kept as it grows: reading the buffer's
+    // last characters would flatten the string being built on every soft line
+    // break (quadratic in a long paragraph).
+    let spaces = 0;
+    const append = (text) => {
+        buffer += text;
+        let end = text.length;
+        while (end > 0 && text.charCodeAt(end - 1) === 32)
+            end -= 1;
+        spaces = end === 0 ? spaces + text.length : text.length - end;
+    };
     const flush = () => {
         if (buffer)
             out.push(...budget.inline(buffer.replace(/\n/g, ' '), marks));
         buffer = '';
+        spaces = 0;
     };
     const push = (text, extra) => {
         flush();
         out.push(...budget.inline(text, sortMarks([...marks, ...extra])));
     };
     const scan = new Scan(source);
+    const extensions = budget.extensions;
+    // The characters that can start an inline construct, registered sigils included.
+    const special = extensions.special;
     let i = 0;
     while (i < source.length) {
         const ch = source[i] ?? '';
@@ -350,23 +454,36 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 continue;
             }
             if (ESCAPABLE.test(next)) {
-                buffer += next;
+                append(next);
                 i += 2;
                 continue;
             }
         }
         if (ch === '\n') {
-            if (/ {2,}$/.test(buffer)) {
-                buffer = buffer.replace(/ +$/, '');
+            // Two or more trailing spaces make a hard break.
+            if (spaces >= 2) {
+                buffer = buffer.slice(0, buffer.length - spaces);
                 flush();
                 out.push({ type: 'break' });
                 budget.chars += 1;
             }
             else
-                buffer += '\n';
+                append('\n');
             i += 1;
             continue;
         }
+        const extension = inLink ? undefined : extensions.bySigil.get(ch);
+        if (extension) {
+            const token = scan.extension(i);
+            const id = token ? source.slice(token.idStart, token.idEnd) : '';
+            if (token && acceptsExtensionId(extensions, extension.name, id)) {
+                push(unescapeMarkdown(source.slice(token.labelStart, token.labelEnd)), [
+                    { type: 'extension', name: extension.name, id },
+                ]);
+                i = token.end;
+                continue;
+            }
+        }
         if (ch === '`') {
             const run = /^`+/.exec(source.slice(i, i + 64))?.[0] ?? '`';
             const close = source.indexOf(run, i + run.length);
@@ -376,7 +493,7 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 i = close + run.length;
                 continue;
             }
-            buffer += run;
+            append(run);
             i += run.length;
             continue;
         }
@@ -392,7 +509,7 @@ function parseInline(source, depth, marks, inLink, out, budget) {
             if (ch === '!' && source[i + 1] === '[') {
                 const image = matchLink(scan, i + 1);
                 if (image) {
-                    buffer += unescapeMarkdown(source.slice(image.labelStart, image.labelEnd));
+                    append(unescapeMarkdown(source.slice(image.labelStart, image.labelEnd)));
                     i = image.end;
                     continue;
                 }
@@ -418,8 +535,12 @@ function parseInline(source, depth, marks, inLink, out, budget) {
                 }
             }
         }
-        buffer += ch;
-        i += 1;
+        // Plain text up to the next character that can open a construct is
+        // copied in one slice, not one character at a time.
+        special.lastIndex = i + 1;
+        const stop = special.test(source) ? special.lastIndex - 1 : source.length;
+        append(source.slice(i, stop));
+        i = stop;
     }
     flush();
 }
@@ -453,19 +574,92 @@ function matchLink(scan, at) {
     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));
+    // A target is read from at most 2,100 characters after the label.
+    const target = readLinkTarget(source.slice(labelEnd + 1, labelEnd + 1 + 2_100), 0);
     if (!target)
         return null;
-    return {
-        labelStart: at + 1,
-        labelEnd,
-        href: target[1] ?? '',
-        end: labelEnd + 1 + target[0].length,
+    return { labelStart: at + 1, labelEnd, href: target.href, end: labelEnd + 1 + target.end };
+}
+const isWhitespace = (char) => char !== undefined && /\s/.test(char);
+/** A target character: not whitespace, a parenthesis or an angle bracket. */
+const isTargetChar = (char) => char !== undefined && !/[\s()<>]/.test(char);
+/**
+ * Reads a link target `(<href> "title")` whose `(` is at `open`, by hand.
+ * It returns what `/\(\s*<?((?:[^\s()<>]|\([^\s()<>]*\))*)>?(?:\s+"[^"\n]*")?\s*\)/y`
+ * returned (the href and the index after `)`), but in linear time: in that
+ * regex `\(\s*`, `\s+"` and `\s*\)` competed for one whitespace run, so
+ * `[a](` + 3,990 spaces + `x` took about 250 ms.
+ */
+function readLinkTarget(source, open) {
+    // The optional title and the closing parenthesis from `from`: the index
+    // after `)`, or -1.
+    const close = (from) => {
+        let at = from;
+        while (isWhitespace(source[at]))
+            at += 1;
+        if (source[at] === ')')
+            return at + 1;
+        if (at === from || source[at] !== '"')
+            return -1;
+        at += 1;
+        while (at < source.length && source[at] !== '"' && source[at] !== '\n')
+            at += 1;
+        if (source[at] !== '"')
+            return -1;
+        at += 1;
+        while (isWhitespace(source[at]))
+            at += 1;
+        return source[at] === ')' ? at + 1 : -1;
     };
+    let at = open + 1;
+    while (isWhitespace(source[at]))
+        at += 1;
+    const afterSpace = at;
+    if (source[at] === '<')
+        at += 1;
+    const hrefStart = at;
+    // Plain characters and balanced `(…)` groups without whitespace inside.
+    for (;;) {
+        if (isTargetChar(source[at]))
+            at += 1;
+        else if (source[at] === '(') {
+            let inner = at + 1;
+            while (isTargetChar(source[inner]))
+                inner += 1;
+            if (source[inner] !== ')')
+                break;
+            at = inner + 1;
+        }
+        else
+            break;
+    }
+    const href = source.slice(hrefStart, at);
+    if (source[at] === '>')
+        at += 1;
+    const end = close(at);
+    if (end !== -1)
+        return { href, end };
+    // The regex backtracked into the leading whitespace: `( "title")` is an
+    // empty href with a title.
+    if (afterSpace > open + 1) {
+        const titled = close(open + 1);
+        if (titled !== -1)
+            return { href: '', end: titled };
+    }
+    return null;
 }
 // ---------------------------------------------------------------------------
 // Writing
 const escapeText = (text) => text.replace(/[\\`*_[\]~<!]/g, '\\$&');
+/** Plain text: a registered sigil before `{` would read as a token, so `{` is escaped. */
+const escapePlain = (text, extensions) => extensions.literal ? escapeText(text).replace(extensions.literal, '$1\\{') : escapeText(text);
+/** An extension token: the label escaped so no closer or delimiter inside it counts. */
+function extensionToken(mark, label, extensions) {
+    const extension = extensions.byName.get(mark.name);
+    if (!extension)
+        return null;
+    return `${extension.sigil}{${mark.id}|${escapeText(label).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);
@@ -483,69 +677,98 @@ function codeSpan(text) {
     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). */
+/**
+ * Move whitespace and trailing backslashes out of strong, em and strike spans
+ * (Markdown cannot open or close there). Works on runs, splitting a run only
+ * where a span edge moves: one pass per mark type, no object per character.
+ */
 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 });
-    }
+    let runs = content.flatMap((node) => node.type === 'break' ? [null] : node.text ? [{ text: node.text, marks: node.marks }] : []);
     for (const type of ['strong', 'em', 'strike']) {
+        const marked = (run) => run?.marks.some((m) => m.type === type) === true;
+        const strip = (run, text) => ({
+            text,
+            marks: run.marks.filter((m) => m.type !== type),
+        });
+        const out = [];
         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)) {
+        while (i < runs.length) {
+            if (!marked(runs[i])) {
+                out.push(runs[i]);
                 i += 1;
                 continue;
             }
+            // A span: marked text, and breaks with marked text on both sides.
             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--);
+            for (let k = i + 1; k < runs.length; k += 1) {
+                if (runs[k] === null)
+                    continue;
+                if (!marked(runs[k]))
+                    break;
+                end = k;
+            }
+            const span = runs.slice(i, end + 1);
+            // Leading whitespace leaves the span, up to the first other character
+            // or break; then trailing whitespace and backslashes, from the end.
+            const head = [];
+            const tail = [];
+            let a = 0;
+            let b = span.length - 1;
+            for (; a <= b; a += 1) {
+                const run = span[a];
+                if (!run)
+                    break;
+                let cut = 0;
+                while (/\s/.test(run.text[cut] ?? ''))
+                    cut += 1;
+                if (cut)
+                    head.push(strip(run, run.text.slice(0, cut)));
+                if (cut < run.text.length) {
+                    span[a] = { text: run.text.slice(cut), marks: run.marks };
+                    break;
+                }
+            }
+            for (; b >= a; b -= 1) {
+                const run = span[b];
+                if (!run)
+                    break;
+                let cut = run.text.length;
+                while (/[\s\\]/.test(run.text[cut - 1] ?? ''))
+                    cut -= 1;
+                if (cut < run.text.length)
+                    tail.push(strip(run, run.text.slice(cut)));
+                if (cut) {
+                    span[b] = { text: run.text.slice(0, cut), marks: run.marks };
+                    break;
+                }
+            }
+            // One push per run: a spread of a long span could overflow the call stack.
+            for (const run of [...head, ...span.slice(a, b + 1), ...tail.reverse()])
+                out.push(run);
             i = end + 1;
         }
+        runs = out;
     }
-    const out = [];
-    for (const c of chars)
-        out.push(c ? { type: 'text', text: c.ch, marks: c.marks } : { type: 'break' });
-    return normalizeInline(out);
+    return normalizeInline(runs.map((run) => (run ? { type: 'text', ...run } : { type: 'break' })));
 }
-function writeInline(content, em) {
+function writeInline(content, em, extensions) {
     const open = { strong: '**', em, strike: '~~' };
-    const texts = content.flatMap((node, index) => (node.type === 'text' ? [{ node, index }] : []));
+    const texts = content.flatMap((node) => (node.type === 'text' ? [{ node }] : []));
     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;
-    };
+    // Code spans and extension tokens are leaves: other marks nest around them.
+    const outer = (marks) => marks.filter((m) => m.type !== 'code' && m.type !== 'extension');
+    // Where the span of each mark starting at text `t` ends (marks that end
+    // later nest outside), computed once from the end so long spans stay linear.
+    const ends = new Array(texts.length);
+    for (let t = texts.length - 1; t >= 0; t -= 1) {
+        const here = new Map();
+        for (const mark of texts[t].node.marks) {
+            const key = markKey(mark);
+            here.set(key, ends[t + 1]?.get(key) ?? t);
+        }
+        ends[t] = here;
+    }
+    const spanEnd = (t, mark) => ends[t]?.get(markKey(mark)) ?? t;
     const ordered = (t) => {
         const marks = outer(texts[t].node.marks);
         const opened = (mark) => {
@@ -562,7 +785,7 @@ function writeInline(content, em) {
     const close = (to) => {
         while (stack.length > to) {
             const mark = stack.pop();
-            out += mark.type === 'link' ? `](${encodeRef(mark.href)})` : open[mark.type];
+            out += mark.type === 'link' ? `](${encodeRef(mark.href)})` : (open[mark.type] ?? '');
         }
     };
     const keepCommon = (wanted) => {
@@ -575,10 +798,11 @@ function writeInline(content, em) {
         return common;
     };
     let t = 0;
-    content.forEach((node, index) => {
+    content.forEach((node) => {
         if (node.type === 'break') {
             // Marks the next text keeps stay open across the break.
-            const next = texts.findIndex((entry) => entry.index > index);
+            // `t` texts are written, so the next one is `texts[t]`.
+            const next = t < texts.length ? t : -1;
             keepCommon(next === -1 ? [] : ordered(next).filter((m) => stack.some((s) => markKey(s) === markKey(m))));
             out += '\\\n';
             return;
@@ -586,10 +810,16 @@ function writeInline(content, em) {
         const wanted = ordered(t);
         const common = keepCommon(wanted);
         for (const mark of wanted.slice(common)) {
-            out += mark.type === 'link' ? '[' : open[mark.type];
+            out += mark.type === 'link' ? '[' : (open[mark.type] ?? '');
             stack.push(mark);
         }
-        out += node.marks.some((m) => m.type === 'code') ? codeSpan(node.text) : escapeText(node.text);
+        const entity = node.marks.find((m) => m.type === 'extension');
+        const token = entity ? extensionToken(entity, node.text, extensions) : null;
+        out +=
+            token ??
+                (node.marks.some((m) => m.type === 'code')
+                    ? codeSpan(node.text)
+                    : escapePlain(node.text, extensions));
         t += 1;
     });
     close(0);
@@ -603,8 +833,8 @@ const sameInline = (a, b) => a.length === b.length &&
         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' });
+function reread(markdown, extensions) {
+    const budget = new LoadBudget({ trust: 'developer', extensions });
     const out = [];
     parseInline(markdown, 0, [], false, out, budget);
     return normalizeInline(out);
@@ -614,11 +844,11 @@ function reread(markdown) {
  * 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);
+function inlineMarkdown(content, lineStart, extensions) {
+    let prepared = prepareMarks(withRegistered(content, extensions));
     const attempt = (em) => {
-        const text = writeInline(prepared, em).split('\n').map(lineStart).join('\n');
-        return sameInline(reread(text), prepared) ? text : null;
+        const text = writeInline(prepared, em, extensions).split('\n').map(lineStart).join('\n');
+        return sameInline(reread(text, extensions), prepared) ? text : null;
     };
     for (const drop of [null, 'em', 'strike', 'strong']) {
         if (drop)
@@ -627,25 +857,34 @@ function inlineMarkdown(content, lineStart) {
         if (text !== null)
             return text;
     }
-    return writeInline(prepared, '*').split('\n').map(lineStart).join('\n');
+    return writeInline(prepared, '*', extensions).split('\n').map(lineStart).join('\n');
+}
+/** Extension marks of unregistered names leave (their label stays plain text). */
+function withRegistered(content, extensions) {
+    const foreign = (mark) => mark.type === 'extension' && !extensions.byName.has(mark.name);
+    if (!content.some((n) => n.type === 'text' && n.marks.some(foreign)))
+        return content;
+    return normalizeInline(content.map((n) => n.type === 'text' && n.marks.some(foreign)
+        ? { ...n, marks: n.marks.filter((m) => !foreign(m)) }
+        : n));
 }
 const indent = (text, by) => text
     .split('\n')
     .map((line) => (line ? by + line : line))
     .join('\n');
-function writeBlocks(blocks) {
+function writeBlocks(blocks, extensions) {
     return blocks
-        .map(writeBlock)
+        .map((block) => writeBlock(block, extensions))
         .filter((text) => text !== '')
         .join('\n\n');
 }
-function writeBlock(block) {
+function writeBlock(block, extensions) {
     switch (block.type) {
         case 'paragraph':
-            return inlineMarkdown(trimEdges(block.content), escapeLineStart);
+            return inlineMarkdown(trimEdges(block.content), escapeLineStart, extensions);
         case 'heading': {
             const flat = block.content.map((n) => (n.type === 'break' ? { type: 'text', text: ' ', marks: [] } : n));
-            const text = inlineMarkdown(trimEdges(normalizeInline(flat)), (line) => line);
+            const text = inlineMarkdown(trimEdges(normalizeInline(flat)), (line) => line, extensions);
             return `${'#'.repeat(block.level)}${text ? ` ${text}` : ''}${text.endsWith('#') ? ' #' : ''}`;
         }
         case 'code': {
@@ -662,13 +901,13 @@ function writeBlock(block) {
                         ? `- [${item.checked ? 'x' : ' '}] `
                         : '- ';
                 const [first, ...rest] = item.blocks;
-                const head = first ? indent(writeBlock(first), '    ').trimStart() : '';
-                const tail = writeBlocks(rest);
+                const head = first ? indent(writeBlock(first, extensions), '    ').trimStart() : '';
+                const tail = writeBlocks(rest, extensions);
                 return `${marker}${head}${tail ? `\n\n${indent(tail, '    ')}` : ''}`;
             })
                 .join('\n');
         case 'quote':
-            return writeBlocks(block.blocks)
+            return writeBlocks(block.blocks, extensions)
                 .split('\n')
                 .map((line) => (line ? `> ${line}` : '>'))
                 .join('\n');
@@ -685,7 +924,8 @@ function trimEdges(content) {
         out.shift();
     while (out.at(-1)?.type === 'break')
         out.pop();
-    const plain = (node) => node?.type === 'text' && !node.marks.some((mark) => mark.type === 'code');
+    const plain = (node) => node?.type === 'text' &&
+        !node.marks.some((mark) => mark.type === 'code' || mark.type === 'extension');
     const first = out[0];
     if (plain(first))
         out[0] = { ...first, text: first.text.trimStart() };
@@ -700,6 +940,6 @@ function trimEdges(content) {
  * 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);
+export function toMarkdown(doc, options = {}) {
+    return writeBlocks(doc.blocks, toInlineExtensions(options.extensions));
 }