nexus-shared 1.1.20 → 2.0.0

package/dist/Helpers/MarkdownHelpers.js

@@ -0,0 +1,775 @@
+/*
+ * Markdown: a small parser for GitHub-flavored Markdown, shared by MarkdownEditor and MarkdownView. It has no
+ * dependencies and no DOM, so it runs on the server, in the browser, and in tests. Raw HTML is never rendered (it stays
+ * text), and links and images keep only safe addresses, so text typed by any user can be shown as it is.
+ *
+ * Supported: headings (# and underlined), paragraphs and line breaks, bold, italic, strikethrough, inline code, code
+ * blocks (fenced and indented), links (inline, reference, <autolinks>, and bare URLs), images, block quotes, bulleted,
+ * numbered, and task lists, tables with column alignment, horizontal lines, backslash escapes, and HTML entities.
+ */
+/** Parses Markdown into blocks for rendering. Never throws, whatever the text. */
+export function parseMarkdown(markdown, options = {}) {
+    const lines = markdown.split(/\r\n?|\n/).map((text, n) => ({ text: expandTabs(text), n }));
+    const context = { refs: new Map(), pending: [] };
+    const blocks = parseBlocks(lines, context);
+    const inline = { refs: context.refs, breaks: options.breaks ?? true };
+    for (const { node, raw } of context.pending)
+        node.children = parseInline(raw, inline);
+    return blocks;
+}
+/** The text of Markdown without its marks, for excerpts, search, and counts. Blocks are separated by a line break. */
+export function markdownToPlainText(markdown) {
+    return blocksText(parseMarkdown(markdown)).trim();
+}
+/**
+ * The address when a link or image may use it, otherwise `null`. Links allow http, https, mailto, tel, and addresses
+ * without a scheme (relative paths and #anchors); images allow http, https, relative paths, and raster data URLs.
+ */
+export function safeUrl(url, kind = "link") {
+    const trimmed = url.trim();
+    if (!trimmed)
+        return null;
+    // Browsers ignore spaces and control characters inside a scheme ("java\tscript:"), so they are ignored here too.
+    const compact = trimmed.replace(/[\s\p{Cc}]/gu, "").toLowerCase();
+    const scheme = /^([a-z][a-z0-9+.-]*):/.exec(compact)?.[1];
+    if (!scheme || scheme === "http" || scheme === "https")
+        return trimmed;
+    if (kind === "link" && (scheme === "mailto" || scheme === "tel"))
+        return trimmed;
+    if (kind === "image" && /^data:image\/(?:png|gif|jpe?g|webp|avif);/.test(compact))
+        return trimmed;
+    return null;
+}
+const FENCE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+const FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*$/;
+const RULE = /^ {0,3}(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})$/;
+const QUOTE = /^ {0,3}> ?(.*)$/;
+const LIST_ITEM = /^( {0,3})([-+*]|\d{1,9}[.)])(?:([ \t]+)(.*))?$/;
+const TASK = /^\[([ xX])\](?:[ \t]+|$)/;
+const SETEXT = /^ {0,3}(=+|-+)[ \t]*$/;
+const TABLE_DELIMITER = /^ {0,3}\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+const REFERENCE = /^ {0,3}\[((?:[^[\]\\]|\\.)+)\]:[ \t]*(<[^<>]*>|\S+)(?:[ \t]+("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\((?:[^()\\]|\\.)*\)))?[ \t]*$/;
+function parseBlocks(lines, context) {
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const text = lines[i].text;
+        if (isBlank(text)) {
+            i++;
+            continue;
+        }
+        // Indented code: four spaces. A paragraph's indented continuation lines never get here.
+        if (indentOf(text) >= 4) {
+            const code = [];
+            while (i < lines.length && (isBlank(lines[i].text) || indentOf(lines[i].text) >= 4))
+                code.push(lines[i++].text.slice(4));
+            while (code.length && isBlank(code[code.length - 1]))
+                code.pop();
+            blocks.push({ type: "code", language: "", text: code.join("\n") });
+            continue;
+        }
+        const fence = openFence(text);
+        if (fence) {
+            const code = [];
+            let end = i + 1;
+            for (; end < lines.length; end++) {
+                const close = FENCE_CLOSE.exec(lines[end].text)?.[1];
+                if (close && close[0] === fence.marks[0] && close.length >= fence.marks.length)
+                    break;
+                code.push(removeIndent(lines[end].text, fence.indent));
+            }
+            blocks.push({ type: "code", language: fence.language, text: code.join("\n") });
+            i = end + 1;
+            continue;
+        }
+        const heading = HEADING.exec(text);
+        if (heading) {
+            const node = { type: "heading", level: heading[1].length, children: [] };
+            // A closing run of # is not part of the heading: "## Title ##".
+            context.pending.push({ node, raw: (heading[2] ?? "").replace(/(?:^|[ \t]+)#+$/, "") });
+            blocks.push(node);
+            i++;
+            continue;
+        }
+        if (RULE.test(text)) {
+            blocks.push({ type: "rule" });
+            i++;
+        }
+        else if (QUOTE.test(text)) {
+            i = parseQuote(lines, i, context, blocks);
+        }
+        else if (LIST_ITEM.test(text)) {
+            i = parseList(lines, i, context, blocks);
+        }
+        else if (isTableStart(lines, i)) {
+            i = parseTable(lines, i, context, blocks);
+        }
+        else {
+            i = parseParagraph(lines, i, context, blocks);
+        }
+    }
+    return blocks;
+}
+function parseQuote(lines, start, context, blocks) {
+    const inner = [];
+    let i = start;
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        const quoted = QUOTE.exec(line.text);
+        if (quoted) {
+            inner.push({ text: quoted[1], n: line.n });
+            continue;
+        }
+        // A line without ">" right after quoted text still belongs to the quoted paragraph.
+        const last = inner[inner.length - 1].text;
+        if (isBlank(line.text) || !continuesParagraph(last) || interruptsParagraph(line.text))
+            break;
+        inner.push(line);
+    }
+    blocks.push({ type: "quote", children: parseBlocks(inner, context) });
+    return i;
+}
+function parseList(lines, start, context, blocks) {
+    const first = LIST_ITEM.exec(lines[start].text);
+    const kind = markerKind(first[2]);
+    const ordered = kind === "." || kind === ")";
+    const list = { type: "list", ordered, start: ordered ? parseInt(first[2], 10) : 1, tight: true, items: [] };
+    let i = start;
+    while (i < lines.length) {
+        const item = LIST_ITEM.exec(lines[i].text);
+        if (!item || RULE.test(lines[i].text) || markerKind(item[2]) !== kind)
+            break;
+        const [, pad = "", marker = "", gap = "", rest = ""] = item;
+        // The item's text starts after the marker and its spaces. Five or more spaces start indented code, one space in.
+        const gapWidth = !rest || gap.length > 4 ? 1 : gap.length;
+        const indent = pad.length + marker.length + gapWidth;
+        const content = [{ text: gap.length > 4 && rest ? " ".repeat(gap.length - 1) + rest : rest, n: lines[i].n }];
+        let end = i + 1;
+        for (; end < lines.length; end++) {
+            const line = lines[end];
+            if (isBlank(line.text)) {
+                content.push({ text: "", n: line.n });
+            }
+            else if (indentOf(line.text) >= indent) {
+                content.push({ text: line.text.slice(indent), n: line.n });
+            }
+            else {
+                // A line that is not indented still continues the item's paragraph, unless it starts something else.
+                const last = content[content.length - 1].text;
+                if (LIST_ITEM.test(line.text) || !continuesParagraph(last) || interruptsParagraph(line.text))
+                    break;
+                content.push({ text: line.text.trimStart(), n: line.n });
+            }
+        }
+        // Blank lines after the item separate it from the next one; they are not part of it.
+        let size = content.length;
+        while (size > 1 && isBlank(content[size - 1].text))
+            size--;
+        const blankAfter = size < content.length;
+        content.length = size;
+        let checked = null;
+        const task = TASK.exec(content[0].text);
+        if (task) {
+            checked = task[1] !== " ";
+            content[0] = { text: content[0].text.slice(task[0].length), n: content[0].n };
+        }
+        const children = parseBlocks(content, context);
+        // A blank line between two blocks of one item makes the whole list loose.
+        if (children.length > 1 && content.some(line => isBlank(line.text)))
+            list.tight = false;
+        list.items.push({ checked, line: lines[i].n, children });
+        i = end;
+        // So does a blank line between two items.
+        const next = blankAfter && i < lines.length ? LIST_ITEM.exec(lines[i].text) : null;
+        if (next && markerKind(next[2]) === kind && !RULE.test(lines[i].text))
+            list.tight = false;
+    }
+    blocks.push(list);
+    return i;
+}
+function parseTable(lines, start, context, blocks) {
+    const head = splitRow(lines[start].text);
+    const align = splitRow(lines[start + 1].text).map((cell) => {
+        const left = cell.startsWith(":");
+        const right = cell.endsWith(":");
+        return left && right ? "center" : right ? "right" : left ? "left" : null;
+    });
+    const rows = [];
+    let i = start + 2;
+    for (; i < lines.length; i++) {
+        const text = lines[i].text;
+        if (isBlank(text) || interruptsParagraph(text))
+            break;
+        const cells = splitRow(text);
+        // Every row has the header's columns: missing cells are empty and extra cells are dropped.
+        rows.push(head.map((_, k) => tableCell(context, cells[k] ?? "")));
+    }
+    blocks.push({ type: "table", align, head: head.map(cell => tableCell(context, cell)), rows });
+    return i;
+}
+function parseParagraph(lines, start, context, blocks) {
+    const raw = [];
+    let level = 0;
+    let i = start;
+    for (; i < lines.length; i++) {
+        const text = lines[i].text;
+        if (isBlank(text))
+            break;
+        if (raw.length) {
+            // A line of = or - under text turns the paragraph into a heading.
+            const underline = SETEXT.exec(text);
+            if (underline) {
+                level = underline[1][0] === "=" ? 1 : 2;
+                i++;
+                break;
+            }
+            if (interruptsParagraph(text) || isTableStart(lines, i))
+                break;
+        }
+        raw.push(text.trimStart());
+    }
+    let first = 0;
+    for (; first < raw.length; first++) {
+        const definition = REFERENCE.exec(raw[first]);
+        const key = definition ? normalizeLabel(definition[1]) : "";
+        if (!key)
+            break;
+        const destination = definition[2];
+        const title = definition[3];
+        if (!context.refs.has(key)) {
+            context.refs.set(key, {
+                href: unescapeText(destination.startsWith("<") ? destination.slice(1, -1) : destination),
+                title: title ? unescapeText(title.slice(1, -1)) : undefined,
+            });
+        }
+    }
+    if (first < raw.length) {
+        const node = level ? { type: "heading", level, children: [] } : { type: "paragraph", children: [] };
+        // Spaces at the end of the last line are not a line break.
+        context.pending.push({ node, raw: raw.slice(first).join("\n").trimEnd() });
+        blocks.push(node);
+    }
+    return i;
+}
+function openFence(text) {
+    const match = FENCE.exec(text);
+    if (!match)
+        return null;
+    const [, indent = "", marks = "", info = ""] = match;
+    // A backtick fence's language cannot hold a backtick: "```a``` b" is inline code.
+    if (marks[0] === "`" && info.includes("`"))
+        return null;
+    return { indent: indent.length, marks, language: unescapeText(info.trim().split(/[ \t]/)[0] ?? "") };
+}
+/** Whether a line starts a block that ends the paragraph above it. */
+function interruptsParagraph(text) {
+    if (openFence(text) || HEADING.test(text) || RULE.test(text) || QUOTE.test(text))
+        return true;
+    const item = LIST_ITEM.exec(text);
+    // Inside a paragraph, only a list item with text starts a list, and a numbered one only from 1.
+    return Boolean(item && item[4]?.trim() && (!/\d/.test(item[2]) || parseInt(item[2], 10) === 1));
+}
+/** Whether a line is paragraph text that a following line without its container's marker can continue. */
+function continuesParagraph(text) {
+    return !isBlank(text) && indentOf(text) < 4 && !openFence(text) && !HEADING.test(text) && !RULE.test(text);
+}
+function isTableStart(lines, i) {
+    const header = lines[i].text;
+    const delimiter = lines[i + 1]?.text;
+    return Boolean(delimiter &&
+        header.includes("|") &&
+        delimiter.includes("|") &&
+        TABLE_DELIMITER.test(delimiter) &&
+        splitRow(header).length === splitRow(delimiter).length);
+}
+/** Cells of a table row. A pipe escaped with a backslash stays in its cell, also inside code. */
+function splitRow(text) {
+    let row = text.trim();
+    if (row.startsWith("|"))
+        row = row.slice(1);
+    if (row.endsWith("|") && !row.endsWith("\\|"))
+        row = row.slice(0, -1);
+    const cells = [];
+    let cell = "";
+    for (let k = 0; k < row.length; k++) {
+        const char = row[k];
+        if (char === "\\" && row[k + 1] === "|") {
+            cell += "|";
+            k++;
+        }
+        else if (char === "|") {
+            cells.push(cell.trim());
+            cell = "";
+        }
+        else {
+            cell += char;
+        }
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+function tableCell(context, raw) {
+    const cell = { children: [] };
+    context.pending.push({ node: cell, raw });
+    return cell;
+}
+const markerKind = (marker) => (/\d/.test(marker) ? marker.slice(-1) : marker);
+const isBlank = (text) => !/\S/.test(text);
+const indentOf = (text) => text.length - text.replace(/^ +/, "").length;
+function removeIndent(text, width) {
+    let k = 0;
+    while (k < width && text[k] === " ")
+        k++;
+    return text.slice(k);
+}
+/** Tabs in a line's indent become spaces, to the next multiple of 4, so indents compare by width. */
+function expandTabs(text) {
+    if (!text.includes("\t"))
+        return text;
+    let column = 0;
+    let k = 0;
+    for (; k < text.length; k++) {
+        if (text[k] === " ")
+            column++;
+        else if (text[k] === "\t")
+            column += 4 - (column % 4);
+        else
+            break;
+    }
+    return " ".repeat(column) + text.slice(k);
+}
+function normalizeLabel(label) {
+    return label.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function blocksText(blocks) {
+    return blocks
+        .map(block => {
+        switch (block.type) {
+            case "heading":
+            case "paragraph":
+                return inlineText(block.children);
+            case "code":
+                return block.text;
+            case "quote":
+                return blocksText(block.children);
+            case "list":
+                return block.items.map(item => blocksText(item.children)).join("\n");
+            case "table":
+                return [block.head, ...block.rows].map(row => row.map(cell => inlineText(cell.children)).join(" ")).join("\n");
+            case "rule":
+                return "";
+        }
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+const PLAIN = /[^\\`<![\]*_~\n&hw]+/y;
+const ESCAPABLE = /^[!-/:-@[-`{-~]$/;
+const AUTOLINK = /<([a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s<>]*)>/y;
+const EMAIL_AUTOLINK = /<([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/y;
+const BARE_URL = /(?:https?:\/\/|www\.)[^\s<]*/y;
+const ENTITY = /&(?:#[xX]([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{1,31}));/y;
+const LABEL = /\[((?:[^[\]\\]|\\.){0,999})\]/y;
+const SPACE = /\s/;
+const PUNCTUATION = /[\p{P}\p{S}]/u;
+function parseInline(source, context) {
+    const nodes = [];
+    const delimiters = [];
+    const brackets = [];
+    let text = "";
+    let i = 0;
+    const flush = () => {
+        if (text)
+            nodes.push({ type: "text", text });
+        text = "";
+    };
+    const push = (node) => {
+        flush();
+        nodes.push(node);
+    };
+    while (i < source.length) {
+        PLAIN.lastIndex = i;
+        const plain = PLAIN.exec(source);
+        if (plain) {
+            text += plain[0];
+            i += plain[0].length;
+            continue;
+        }
+        const char = source[i];
+        switch (char) {
+            case "\\": {
+                const next = source[i + 1] ?? "";
+                if (next === "\n") {
+                    text = text.replace(/ +$/, "");
+                    push({ type: "break" });
+                    i = skipSpaces(source, i + 2);
+                }
+                else if (ESCAPABLE.test(next)) {
+                    text += next;
+                    i += 2;
+                }
+                else {
+                    text += char;
+                    i++;
+                }
+                break;
+            }
+            case "\n": {
+                // Two spaces before a line break always break the line; without them, only with `breaks`.
+                const hard = / {2,}$/.test(text);
+                text = text.replace(/ +$/, "");
+                if (hard || context.breaks)
+                    push({ type: "break" });
+                else
+                    text += "\n";
+                i = skipSpaces(source, i + 1);
+                break;
+            }
+            case "`": {
+                const run = runLength(source, i, char);
+                const close = findBacktickRun(source, i + run, run);
+                if (close < 0) {
+                    text += source.slice(i, i + run);
+                    i += run;
+                    break;
+                }
+                let code = source.slice(i + run, close).replace(/\n/g, " ");
+                if (code.startsWith(" ") && code.endsWith(" ") && /[^ ]/.test(code))
+                    code = code.slice(1, -1);
+                push({ type: "code", text: code });
+                i = close + run;
+                break;
+            }
+            case "<": {
+                AUTOLINK.lastIndex = i;
+                EMAIL_AUTOLINK.lastIndex = i;
+                const url = AUTOLINK.exec(source);
+                const email = url ? null : EMAIL_AUTOLINK.exec(source);
+                const found = url ?? email;
+                if (found) {
+                    push({ type: "link", href: safeUrl(email ? `mailto:${found[1]}` : found[1]), children: [{ type: "text", text: found[1] }] });
+                    i += found[0].length;
+                }
+                else {
+                    text += char;
+                    i++;
+                }
+                break;
+            }
+            case "!":
+            case "[": {
+                const image = char === "!";
+                if (image && source[i + 1] !== "[") {
+                    text += char;
+                    i++;
+                    break;
+                }
+                flush();
+                const node = { type: "text", text: image ? "![" : "[" };
+                nodes.push(node);
+                i += image ? 2 : 1;
+                brackets.push({ node, image, active: true, bottom: delimiters.length, labelStart: i });
+                break;
+            }
+            case "]": {
+                flush();
+                const bracket = brackets.pop();
+                const target = bracket?.active ? linkTarget(source, i + 1, context.refs, source.slice(bracket.labelStart, i)) : null;
+                if (!bracket || !target) {
+                    text += char;
+                    i++;
+                    break;
+                }
+                const children = nodes.splice(nodes.indexOf(bracket.node) + 1);
+                nodes.pop();
+                processEmphasis(children, delimiters, bracket.bottom);
+                delimiters.length = bracket.bottom;
+                if (bracket.image) {
+                    nodes.push({ type: "image", src: safeUrl(target.href, "image"), alt: inlineText(children), title: target.title });
+                }
+                else {
+                    nodes.push({ type: "link", href: safeUrl(target.href), title: target.title, children: mergeText(children) });
+                    for (const open of brackets)
+                        if (!open.image)
+                            open.active = false;
+                }
+                i = target.end;
+                break;
+            }
+            case "*":
+            case "_":
+            case "~": {
+                const run = runLength(source, i, char);
+                // Strikethrough takes exactly two tildes, so "~20 min" and "~~~" stay text.
+                if (char === "~" && run !== 2) {
+                    text += source.slice(i, i + run);
+                    i += run;
+                    break;
+                }
+                flush();
+                const node = { type: "text", text: source.slice(i, i + run) };
+                nodes.push(node);
+                const { canOpen, canClose } = flanking(char, source[i - 1] ?? " ", source[i + run] ?? " ");
+                if (canOpen || canClose)
+                    delimiters.push({ char, node, count: run, length: run, canOpen, canClose, active: true });
+                i += run;
+                break;
+            }
+            case "&": {
+                ENTITY.lastIndex = i;
+                const entity = ENTITY.exec(source);
+                const decoded = entity ? decodeEntity(entity[1], entity[2], entity[3]) : null;
+                if (decoded === null) {
+                    text += char;
+                    i++;
+                }
+                else {
+                    text += decoded;
+                    i += entity[0].length;
+                }
+                break;
+            }
+            case "h":
+            case "w": {
+                // A bare URL starts a word, and never inside a link's text.
+                const before = source[i - 1];
+                const url = before === undefined || /[\s*_~(]/.test(before) ? bareUrl(source, i) : null;
+                if (url && !brackets.some(open => open.active && !open.image)) {
+                    push({ type: "link", href: safeUrl(url.startsWith("www.") ? `http://${url}` : url), children: [{ type: "text", text: url }] });
+                    i += url.length;
+                }
+                else {
+                    text += char;
+                    i++;
+                }
+                break;
+            }
+            default:
+                text += char;
+                i++;
+        }
+    }
+    flush();
+    processEmphasis(nodes, delimiters, 0);
+    return mergeText(nodes);
+}
+/**
+ * Pairs emphasis delimiters above `bottom`, as CommonMark describes: each closer takes the nearest opener of the same
+ * character, `**` makes bold and `*` italic, and runs whose lengths add up to a multiple of three do not pair when
+ * one of them could both open and close.
+ */
+function processEmphasis(nodes, delimiters, bottom) {
+    // Where the search for an opener stopped last time, by closer kind, so text full of unmatched runs stays linear.
+    const openersBottom = new Map();
+    for (let c = bottom; c < delimiters.length; c++) {
+        const closer = delimiters[c];
+        while (closer.active && closer.canClose) {
+            const key = `${closer.char}${closer.canOpen ? 1 : 0}${closer.length % 3}`;
+            const floor = Math.max(bottom, openersBottom.get(key) ?? bottom);
+            let o = c - 1;
+            let opener;
+            for (; o >= floor; o--) {
+                const candidate = delimiters[o];
+                if (!candidate.active || candidate.char !== closer.char || !candidate.canOpen)
+                    continue;
+                const bothWays = candidate.canClose || closer.canOpen;
+                if (bothWays && (candidate.length + closer.length) % 3 === 0 && (candidate.length % 3 !== 0 || closer.length % 3 !== 0))
+                    continue;
+                opener = candidate;
+                break;
+            }
+            if (!opener) {
+                openersBottom.set(key, c);
+                if (!closer.canOpen)
+                    closer.active = false;
+                break;
+            }
+            const use = closer.count >= 2 && opener.count >= 2 ? 2 : 1;
+            opener.count -= use;
+            closer.count -= use;
+            opener.node.text = opener.node.text.slice(use);
+            closer.node.text = closer.node.text.slice(use);
+            const start = nodes.indexOf(opener.node);
+            const end = nodes.indexOf(closer.node);
+            const children = mergeText(nodes.splice(start + 1, end - start - 1));
+            nodes.splice(start + 1, 0, { type: closer.char === "~" ? "strike" : use === 2 ? "strong" : "emphasis", children });
+            for (let k = o + 1; k < c; k++)
+                delimiters[k].active = false;
+            if (opener.count === 0) {
+                opener.active = false;
+                nodes.splice(nodes.indexOf(opener.node), 1);
+            }
+            if (closer.count === 0) {
+                closer.active = false;
+                nodes.splice(nodes.indexOf(closer.node), 1);
+            }
+        }
+    }
+}
+/** Whether a run of `char` between `before` and `after` can open or close emphasis. */
+function flanking(char, before, after) {
+    const spaceBefore = SPACE.test(before);
+    const spaceAfter = SPACE.test(after);
+    const punctuationBefore = PUNCTUATION.test(before);
+    const punctuationAfter = PUNCTUATION.test(after);
+    const left = !spaceAfter && (!punctuationAfter || spaceBefore || punctuationBefore);
+    const right = !spaceBefore && (!punctuationBefore || spaceAfter || punctuationAfter);
+    // An underscore inside a word (snake_case_name) is not emphasis.
+    if (char === "_")
+        return { canOpen: left && (!right || punctuationBefore), canClose: right && (!left || punctuationAfter) };
+    return { canOpen: left, canClose: right };
+}
+/** The address and title after a link's text: `(url "title")`, `[label]`, `[]`, or nothing for `[label]` alone. */
+function linkTarget(source, at, refs, label) {
+    if (source[at] === "(") {
+        const inline = inlineTarget(source, at);
+        if (inline)
+            return inline;
+    }
+    LABEL.lastIndex = at;
+    const full = LABEL.exec(source);
+    const key = normalizeLabel(full?.[1]?.trim() ? full[1] : label);
+    const reference = key ? refs.get(key) : undefined;
+    return reference ? { ...reference, end: full ? at + full[0].length : at } : null;
+}
+function inlineTarget(source, at) {
+    let i = skipWhitespace(source, at + 1);
+    let href;
+    if (source[i] === "<") {
+        const close = source.slice(i + 1).search(/[<>\n]/);
+        if (close < 0 || source[i + 1 + close] !== ">")
+            return null;
+        href = source.slice(i + 1, i + 1 + close);
+        i += close + 2;
+    }
+    else {
+        const start = i;
+        let depth = 0;
+        for (; i < source.length; i++) {
+            const char = source[i];
+            if (char === "\\" && ESCAPABLE.test(source[i + 1] ?? ""))
+                i++;
+            else if (char === "(")
+                depth++;
+            else if (char === ")" && depth === 0)
+                break;
+            else if (char === ")")
+                depth--;
+            else if (char <= " ")
+                break;
+        }
+        if (depth !== 0)
+            return null;
+        href = source.slice(start, i);
+    }
+    const afterHref = i;
+    i = skipWhitespace(source, i);
+    let title;
+    const quote = source[i];
+    if (i > afterHref && (quote === '"' || quote === "'" || quote === "(")) {
+        const close = quote === "(" ? ")" : quote;
+        let end = i + 1;
+        while (end < source.length && source[end] !== close)
+            end += source[end] === "\\" ? 2 : 1;
+        if (end >= source.length)
+            return null;
+        title = unescapeText(source.slice(i + 1, end));
+        i = skipWhitespace(source, end + 1);
+    }
+    return source[i] === ")" ? { href: unescapeText(href), title, end: i + 1 } : null;
+}
+function bareUrl(source, at) {
+    BARE_URL.lastIndex = at;
+    let url = BARE_URL.exec(source)?.[0];
+    if (!url)
+        return null;
+    // Punctuation at the end belongs to the sentence, and so does a closing parenthesis that opened before the URL.
+    for (;;) {
+        const last = url.slice(-1);
+        if (/[?!.,:;*_~'"]/.test(last))
+            url = url.slice(0, -1);
+        else if (last === ")" && url.split(")").length > url.split("(").length)
+            url = url.slice(0, -1);
+        else
+            break;
+    }
+    return /^(?:https?:\/\/|www\.)[\p{L}\p{N}_-]/u.test(url) ? url : null;
+}
+function findBacktickRun(source, from, length) {
+    let at = source.indexOf("`", from);
+    while (at >= 0) {
+        const run = runLength(source, at, "`");
+        if (run === length)
+            return at;
+        at = source.indexOf("`", at + run);
+    }
+    return -1;
+}
+function runLength(source, at, char) {
+    let end = at;
+    while (source[end] === char)
+        end++;
+    return end - at;
+}
+function skipSpaces(source, at) {
+    while (source[at] === " ")
+        at++;
+    return at;
+}
+function skipWhitespace(source, at) {
+    while (source[at] === " " || source[at] === "\t" || source[at] === "\n")
+        at++;
+    return at;
+}
+function mergeText(nodes) {
+    const merged = [];
+    for (const node of nodes) {
+        const last = merged[merged.length - 1];
+        if (node.type !== "text")
+            merged.push(node);
+        else if (!node.text)
+            continue;
+        else if (last?.type === "text")
+            merged[merged.length - 1] = { type: "text", text: last.text + node.text };
+        else
+            merged.push({ type: "text", text: node.text });
+    }
+    return merged;
+}
+function inlineText(nodes) {
+    return nodes
+        .map(node => {
+        switch (node.type) {
+            case "text":
+            case "code":
+                return node.text;
+            case "image":
+                return node.alt;
+            case "break":
+                return "\n";
+            default:
+                return inlineText(node.children);
+        }
+    })
+        .join("");
+}
+/** Code points of the named entities most often typed in text. Others stay as written. */
+const NAMED_ENTITIES = new Map([
+    ["amp", 38], ["lt", 60], ["gt", 62], ["quot", 34], ["apos", 39], ["nbsp", 160], ["copy", 169], ["reg", 174],
+    ["trade", 8482], ["hellip", 8230], ["mdash", 8212], ["ndash", 8211], ["lsquo", 8216], ["rsquo", 8217],
+    ["ldquo", 8220], ["rdquo", 8221], ["laquo", 171], ["raquo", 187], ["times", 215], ["divide", 247], ["deg", 176],
+    ["plusmn", 177], ["middot", 183], ["bull", 8226], ["larr", 8592], ["rarr", 8594], ["uarr", 8593], ["darr", 8595],
+    ["euro", 8364], ["pound", 163], ["yen", 165], ["cent", 162], ["sect", 167], ["para", 182],
+]);
+function decodeEntity(hex, decimal, name) {
+    const code = hex ? parseInt(hex, 16) : decimal ? parseInt(decimal, 10) : NAMED_ENTITIES.get(name ?? "");
+    if (code === undefined)
+        return null;
+    const valid = code > 0 && code <= 0x10ffff && (code < 0xd800 || code > 0xdfff);
+    return String.fromCodePoint(valid ? code : 0xfffd);
+}
+/** Backslash escapes and entities in an address, a title, or a code block's language. */
+function unescapeText(text) {
+    return text.replace(/\\([!-/:-@[-`{-~])|&(?:#[xX]([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{1,31}));/g, (whole, escaped, hex, decimal, name) => escaped ?? decodeEntity(hex, decimal, name) ?? whole);
+}