@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/file-viewer/markdown/blocks.js

@@ -0,0 +1,277 @@
+// Block markdown: the structure a document is made of, read line by line.
+//
+// The subset is the one real documents are written in — headings, fences,
+// lists, quotes, rules, GFM tables, paragraphs. What is deliberately absent
+// is raw HTML: an HTML block is kept as the text it is, because rendering it
+// would be the one thing `types.ts` says this parser must never do.
+import { parseInline, parseInlineLines } from "./inline.js";
+const ATX_HEADING = /^ {0,3}(#{1,6})(?:\s+(.*?))?\s*(?:\s#+)?$/;
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([^`\s]*)/;
+const RULE = /^ {0,3}([-*_])[ \t]*(?:\1[ \t]*){2,}$/;
+const QUOTE = /^ {0,3}> ?/;
+const BULLET = /^(\s*)([-*+]|\d{1,9}[.)])(\s+|$)/;
+const SETEXT = /^ {0,3}(=+|-+)\s*$/;
+const TABLE_DELIMITER = /^\s*\|?(?:\s*:?-+:?\s*\|)+\s*:?-*:?\s*\|?\s*$/;
+const isBlank = (line) => line.trim() === "";
+const indentOf = (line) => line.length - line.trimStart().length;
+/** Does a line interrupt the paragraph above it? */
+function startsBlock(line) {
+    return (ATX_HEADING.test(line) ||
+        FENCE.test(line) ||
+        RULE.test(line) ||
+        QUOTE.test(line) ||
+        BULLET.test(line));
+}
+function bulletOf(line) {
+    const found = BULLET.exec(line);
+    // `- - -` is a rule wearing a bullet's clothes, and the rule reading wins.
+    if (found === null || RULE.test(line))
+        return null;
+    const [whole, lead, marker] = found;
+    return {
+        ordered: /\d/.test(marker),
+        start: /\d/.test(marker) ? Number.parseInt(marker, 10) : 1,
+        indent: lead.length,
+        contentIndent: whole.length,
+        content: line.slice(whole.length),
+    };
+}
+function splitRow(line) {
+    const cells = [];
+    let cell = "";
+    const body = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+    for (let i = 0; i < body.length; i += 1) {
+        if (body[i] === "\\" && body[i + 1] === "|") {
+            cell += "|";
+            i += 1;
+            continue;
+        }
+        if (body[i] === "|") {
+            cells.push(cell.trim());
+            cell = "";
+            continue;
+        }
+        cell += body[i];
+    }
+    cells.push(cell.trim());
+    return cells;
+}
+function alignmentOf(cell) {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right)
+        return "center";
+    if (right)
+        return "right";
+    if (left)
+        return "left";
+    return null;
+}
+// Keep source positions through cell trimming and escaped pipes. The inline
+// parser owns unescaping, so a deleted escape never shifts later annotations.
+function inlineCells(line, source) {
+    const cells = [];
+    const lead = line.length - line.trimStart().length;
+    const start = lead + (line[lead] === "|" ? 1 : 0);
+    const trimmedEnd = line.trimEnd().length;
+    const end = trimmedEnd - (line[trimmedEnd - 1] === "|" ? 1 : 0);
+    let cellStart = start;
+    const push = (to) => {
+        const raw = line.slice(cellStart, to);
+        const from = cellStart + raw.length - raw.trimStart().length;
+        const cell = raw.trim();
+        cells.push(parseInline(cell, false, source?.slice(from, from + cell.length)));
+    };
+    for (let i = start; i < end; i += 1) {
+        if (line[i] === "\\" && line[i + 1] === "|") {
+            i += 1;
+            continue;
+        }
+        if (line[i] === "|") {
+            push(i);
+            cellStart = i + 1;
+        }
+    }
+    push(end);
+    return cells;
+}
+export function parseBlocks(lines, sources) {
+    const out = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        const source = sources?.[index];
+        if (isBlank(line)) {
+            index += 1;
+            continue;
+        }
+        const fence = FENCE.exec(line);
+        if (fence !== null) {
+            const marker = fence[1][0];
+            const body = [];
+            index += 1;
+            while (index < lines.length) {
+                const closing = FENCE.exec(lines[index]);
+                if (closing !== null && closing[1][0] === marker && closing[1].length >= fence[1].length) {
+                    index += 1;
+                    break;
+                }
+                body.push(lines[index]);
+                index += 1;
+            }
+            out.push({ type: "code", language: fence[2] === "" ? null : fence[2], text: body.join("\n") });
+            continue;
+        }
+        const heading = ATX_HEADING.exec(line);
+        if (heading !== null) {
+            out.push({
+                type: "heading",
+                level: heading[1].length,
+                children: parseInline(heading[2] ?? "", false, source?.slice(line.indexOf(heading[2] ?? "", (line.length - line.trimStart().length) + heading[1].length))),
+            });
+            index += 1;
+            continue;
+        }
+        if (RULE.test(line)) {
+            out.push({ type: "rule" });
+            index += 1;
+            continue;
+        }
+        if (QUOTE.test(line)) {
+            const body = [];
+            const bodySources = [];
+            while (index < lines.length) {
+                if (QUOTE.test(lines[index])) {
+                    bodySources.push(sources?.[index].slice(QUOTE.exec(lines[index])[0].length) ?? []);
+                    body.push(lines[index].replace(QUOTE, ""));
+                    index += 1;
+                    continue;
+                }
+                // A quote runs on through unmarked lines, the way a paragraph does,
+                // and stops at a blank one.
+                if (isBlank(lines[index]) || startsBlock(lines[index]))
+                    break;
+                body.push(lines[index]);
+                bodySources.push(sources?.[index] ?? []);
+                index += 1;
+            }
+            out.push({ type: "quote", children: parseBlocks(body, sources === undefined ? undefined : bodySources) });
+            continue;
+        }
+        if (line.includes("|") &&
+            index + 1 < lines.length &&
+            TABLE_DELIMITER.test(lines[index + 1]) &&
+            splitRow(lines[index]).length === splitRow(lines[index + 1]).length) {
+            const head = inlineCells(lines[index], sources?.[index]);
+            const align = splitRow(lines[index + 1]).map(alignmentOf);
+            index += 2;
+            const rows = [];
+            while (index < lines.length && lines[index].includes("|") && !isBlank(lines[index])) {
+                rows.push(inlineCells(lines[index], sources?.[index]));
+                index += 1;
+            }
+            out.push({ type: "table", head, align, rows });
+            continue;
+        }
+        const bullet = bulletOf(line);
+        if (bullet !== null) {
+            const items = [];
+            let tight = true;
+            let pendingBlank = false;
+            while (index < lines.length) {
+                if (isBlank(lines[index])) {
+                    pendingBlank = true;
+                    index += 1;
+                    continue;
+                }
+                const next = bulletOf(lines[index]);
+                // A deeper bullet was already swallowed by the item above it, so
+                // anything at a different indent here closes this list. So does a
+                // change of marker kind: `1.` after `-` is a second list, not a
+                // seventh item.
+                if (next === null || next.indent !== bullet.indent || next.ordered !== bullet.ordered) {
+                    break;
+                }
+                if (items.length > 0 && pendingBlank)
+                    tight = false;
+                pendingBlank = false;
+                const body = [next.content];
+                const bodySources = [sources?.[index].slice(next.contentIndent) ?? []];
+                index += 1;
+                while (index < lines.length) {
+                    if (isBlank(lines[index])) {
+                        let lookahead = index;
+                        while (lookahead < lines.length && isBlank(lines[lookahead]))
+                            lookahead += 1;
+                        if (lookahead < lines.length &&
+                            indentOf(lines[lookahead]) >= next.contentIndent &&
+                            bulletOf(lines[lookahead])?.indent !== bullet.indent) {
+                            body.push("");
+                            bodySources.push([]);
+                            index = lookahead;
+                            tight = false;
+                            continue;
+                        }
+                        break;
+                    }
+                    if (indentOf(lines[index]) >= next.contentIndent) {
+                        body.push(lines[index].slice(next.contentIndent));
+                        bodySources.push(sources?.[index].slice(next.contentIndent) ?? []);
+                        index += 1;
+                        continue;
+                    }
+                    // A wrapped line under a bullet needs no indent to belong to it.
+                    if (!startsBlock(lines[index])) {
+                        body.push(lines[index].trim());
+                        bodySources.push(sources?.[index].slice(lines[index].length - lines[index].trimStart().length) ?? []);
+                        index += 1;
+                        continue;
+                    }
+                    break;
+                }
+                items.push(parseBlocks(body, sources === undefined ? undefined : bodySources));
+            }
+            out.push({ type: "list", ordered: bullet.ordered, start: bullet.start, tight, items });
+            continue;
+        }
+        // Four spaces of indent with no list above it is a code block.
+        if (/^ {4}/.test(line)) {
+            const body = [];
+            while (index < lines.length && (/^ {4}/.test(lines[index]) || isBlank(lines[index]))) {
+                body.push(lines[index].slice(4));
+                index += 1;
+            }
+            while (body.length > 0 && body[body.length - 1].trim() === "")
+                body.pop();
+            out.push({ type: "code", language: null, text: body.join("\n") });
+            continue;
+        }
+        const paragraph = [];
+        const paragraphSources = [];
+        while (index < lines.length && !isBlank(lines[index]) && !startsBlock(lines[index])) {
+            paragraph.push(lines[index]);
+            paragraphSources.push(sources?.[index] ?? []);
+            index += 1;
+        }
+        // A `===` or `---` under a paragraph makes it a heading after the fact,
+        // which is why the underline can only be recognised from here.
+        const underline = index < lines.length ? SETEXT.exec(lines[index]) : null;
+        if (underline !== null && paragraph.length > 0) {
+            index += 1;
+            out.push({
+                type: "heading",
+                level: underline[1][0] === "=" ? 1 : 2,
+                children: parseInlineLines(paragraph, sources === undefined ? undefined : paragraphSources),
+            });
+            continue;
+        }
+        if (paragraph.length > 0) {
+            out.push({ type: "paragraph", children: parseInlineLines(paragraph, sources === undefined ? undefined : paragraphSources) });
+            continue;
+        }
+        // Nothing claimed the line; take it as text so the loop always advances.
+        out.push({ type: "paragraph", children: parseInline(line, false, source) });
+        index += 1;
+    }
+    return out;
+}

package/dist/components/file-viewer/markdown/index.d.ts

@@ -0,0 +1,4 @@
+import type { Block } from "./types.js";
+export type { Alignment, Block, Inline } from "./types.js";
+/** Parse a whole document. Pure: no DOM, no network, no clock. */
+export declare function parseMarkdown(text: string, trackSource?: boolean): readonly Block[];

package/dist/components/file-viewer/markdown/index.js

@@ -0,0 +1,35 @@
+// Markdown, parsed to a tree. See `types.ts` for why it is never a string.
+import { parseBlocks } from "./blocks.js";
+/** Parse a whole document. Pure: no DOM, no network, no clock. */
+export function parseMarkdown(text, trackSource = false) {
+    if (!trackSource) {
+        const lines = text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.replace(/\t/g, "    "));
+        return parseBlocks(lines);
+    }
+    // Maps use UTF-16 source offsets, matching JavaScript string slicing. They
+    // are optional: ordinary files pay no per-character mapping cost.
+    const lines = [];
+    const sources = [];
+    let line = "";
+    let positions = [];
+    for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (char === "\r" || char === "\n") {
+            lines.push(line);
+            sources.push(positions);
+            line = "";
+            positions = [];
+            if (char === "\r" && text[i + 1] === "\n")
+                i += 1;
+        }
+        else {
+            const value = char === "\t" ? "    " : char;
+            line += value;
+            for (let j = 0; j < value.length; j += 1)
+                positions.push(i);
+        }
+    }
+    lines.push(line);
+    sources.push(positions);
+    return parseBlocks(lines, sources);
+}

package/dist/components/file-viewer/markdown/inline.d.ts

@@ -0,0 +1,10 @@
+import type { Inline } from "./types.js";
+/**
+ * @param insideLink Suppresses links inside a link's own label. `[https://x.dev](https://y.dev)`
+ *   is a real and common way to write a README line, and autolinking the label
+ *   puts an `<a>` inside an `<a>` — markup no browser is obliged to keep.
+ */
+export declare function parseInline(text: string, insideLink?: boolean, source?: readonly number[]): readonly Inline[];
+/** Split a paragraph's lines into inline nodes, honouring the two ways
+ * markdown spells a hard break. */
+export declare function parseInlineLines(lines: readonly string[], sources?: readonly (readonly number[])[]): readonly Inline[];

package/dist/components/file-viewer/markdown/inline.js

@@ -0,0 +1,178 @@
+// Inline markdown: the marks inside one paragraph's worth of text.
+//
+// A left-to-right scanner rather than a chain of replacements. Replacement
+// chains are how a naive renderer ends up emphasising the middle of a URL and
+// bolding across a code span — the order of the passes decides the answer,
+// and there is no order that is right for every document.
+/**
+ * `[label](href)` and `![alt](src)`, with the optional "title" ignored.
+ *
+ * The href carries one level of balanced parentheses, because
+ * `…/wiki/Foo_(bar)` is a real link and stopping at the first `)` truncated
+ * it and left the other one loose in the prose. One level is what a regex can
+ * count and what every such URL actually uses.
+ */
+const LINK = /^!?\[((?:[^[\]\\]|\\.|\[[^\]]*\])*)\]\(\s*(<[^>]*>|(?:[^\s()]|\([^\s()]*\))*)(?:\s+"[^"]*")?\s*\)/;
+const AUTOLINK = /^<((?:https?|mailto|file):[^>\s]+)>/;
+const BARE_URL = /^https?:\/\/[^\s<>()[\]"']+[^\s<>()[\]"'.,;:!?]/;
+/** A run of backticks opens a code span that the same run closes. */
+const CODE_FENCE = /^`+/;
+const DELIMITERS = [
+    { mark: "***", type: "strong" },
+    { mark: "___", type: "strong" },
+    { mark: "**", type: "strong" },
+    { mark: "__", type: "strong" },
+    { mark: "~~", type: "strike" },
+    { mark: "*", type: "emphasis" },
+    { mark: "_", type: "emphasis" },
+];
+/** `_` inside `snake_case` is a word character, not an emphasis mark. The
+ * test is what surrounds the run, which is why it cannot be a regex on the
+ * mark alone. */
+function opensRun(text, at, mark) {
+    const after = text[at + mark.length] ?? "";
+    if (after === "" || /\s/.test(after))
+        return false;
+    if (mark[0] !== "_")
+        return true;
+    const before = text[at - 1] ?? "";
+    return !/[A-Za-z0-9]/.test(before);
+}
+function closesRun(text, at, mark) {
+    const before = text[at - 1] ?? "";
+    if (before === "" || /\s/.test(before))
+        return false;
+    if (mark[0] !== "_")
+        return true;
+    const after = text[at + mark.length] ?? "";
+    return !/[A-Za-z0-9]/.test(after);
+}
+/** Where `mark` next closes a run opened at `from`, or -1. */
+function findClose(text, from, mark) {
+    let at = from;
+    while (at < text.length) {
+        const next = text.indexOf(mark, at);
+        if (next === -1)
+            return -1;
+        if (text[next - 1] === "\\") {
+            at = next + mark.length;
+            continue;
+        }
+        if (closesRun(text, next, mark))
+            return next;
+        at = next + mark.length;
+    }
+    return -1;
+}
+/**
+ * @param insideLink Suppresses links inside a link's own label. `[https://x.dev](https://y.dev)`
+ *   is a real and common way to write a README line, and autolinking the label
+ *   puts an `<a>` inside an `<a>` — markup no browser is obliged to keep.
+ */
+export function parseInline(text, insideLink = false, source) {
+    const out = [];
+    let plain = "";
+    let positions = [];
+    let index = 0;
+    const flush = () => {
+        if (plain === "")
+            return;
+        out.push({ type: "text", value: plain, ...(source === undefined ? {} : { source: positions }) });
+        plain = "";
+        positions = [];
+    };
+    const push = (node) => {
+        flush();
+        out.push(node);
+    };
+    while (index < text.length) {
+        const rest = text.slice(index);
+        const char = text[index];
+        if (char === "\\" && index + 1 < text.length && /[\\`*_{}[\]()#+\-.!<>~|]/.test(text[index + 1])) {
+            plain += text[index + 1];
+            if (source !== undefined)
+                positions.push(source[index + 1]);
+            index += 2;
+            continue;
+        }
+        if (char === "`") {
+            const fence = CODE_FENCE.exec(rest)?.[0] ?? "`";
+            const close = text.indexOf(fence, index + fence.length);
+            if (close !== -1) {
+                const body = text.slice(index + fence.length, close);
+                // CommonMark strips one space on each side, so `` ` `` can hold a
+                // backtick without the spaces becoming content.
+                const trimmed = body.length > 2 && body.startsWith(" ") && body.endsWith(" ") ? body.slice(1, -1) : body;
+                push({ type: "code", value: trimmed });
+                index = close + fence.length;
+                continue;
+            }
+        }
+        // An image inside a link label is legal markup — a linked thumbnail — so
+        // only the link half of this is suppressed.
+        if (char === "[" || (char === "!" && text[index + 1] === "[")) {
+            const found = LINK.exec(rest);
+            const isImage = found !== null && found[0].startsWith("!");
+            if (found !== null && (isImage || !insideLink)) {
+                const target = found[2].replace(/^<|>$/g, "");
+                if (isImage) {
+                    push({ type: "image", src: target, alt: found[1] });
+                }
+                else {
+                    push({ type: "link", href: target, children: parseInline(found[1], true) });
+                }
+                index += found[0].length;
+                continue;
+            }
+        }
+        if (char === "<" && !insideLink) {
+            const found = AUTOLINK.exec(rest);
+            if (found !== null) {
+                push({ type: "link", href: found[1], children: [{ type: "text", value: found[1] }] });
+                index += found[0].length;
+                continue;
+            }
+        }
+        if (char === "h" && !insideLink && (index === 0 || /[\s(]/.test(text[index - 1] ?? " "))) {
+            const found = BARE_URL.exec(rest);
+            if (found !== null) {
+                push({ type: "link", href: found[0], children: [{ type: "text", value: found[0] }] });
+                index += found[0].length;
+                continue;
+            }
+        }
+        const delimiter = DELIMITERS.find((candidate) => rest.startsWith(candidate.mark) && opensRun(text, index, candidate.mark));
+        if (delimiter !== undefined) {
+            const close = findClose(text, index + delimiter.mark.length, delimiter.mark);
+            if (close !== -1) {
+                const inner = parseInline(text.slice(index + delimiter.mark.length, close), insideLink, source?.slice(index + delimiter.mark.length, close));
+                // `***bold italic***` is one mark carrying two, and nesting it here
+                // keeps the delimiter table flat.
+                push(delimiter.mark.length === 3
+                    ? { type: "strong", children: [{ type: "emphasis", children: inner }] }
+                    : { type: delimiter.type, children: inner });
+                index = close + delimiter.mark.length;
+                continue;
+            }
+        }
+        plain += char;
+        if (source !== undefined)
+            positions.push(source[index]);
+        index += 1;
+    }
+    flush();
+    return out;
+}
+/** Split a paragraph's lines into inline nodes, honouring the two ways
+ * markdown spells a hard break. */
+export function parseInlineLines(lines, sources) {
+    const out = [];
+    lines.forEach((line, index) => {
+        const hard = /(?: {2,}|\\)$/.test(line);
+        out.push(...parseInline(hard ? line.replace(/(?: {2,}|\\)$/, "") : line.trimEnd(), false, sources?.[index]));
+        if (index === lines.length - 1)
+            return;
+        out.push(hard ? { type: "break" } : { type: "text", value: " " });
+    });
+    return out;
+}

package/dist/components/file-viewer/markdown/render.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+import type { Block } from "./types.js";
+export type InlineTextRenderer = (value: string, source?: readonly number[]) => ReactNode;
+export declare function MarkdownBlocks({ blocks, renderText, }: {
+    readonly blocks: readonly Block[];
+    /** Optional decoration for plain text nodes. Code and link targets remain
+     * literal, so callers cannot accidentally nest an action inside a link. */
+    readonly renderText?: InlineTextRenderer | undefined;
+}): import("react").JSX.Element;

package/dist/components/file-viewer/markdown/render.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// The markdown tree, as React elements.
+//
+// Two rules this file exists to keep:
+//
+//  1. **No `dangerouslySetInnerHTML`, anywhere.** The parser never produces
+//     markup and this never interprets any; a README in someone else's
+//     repository cannot reach the DOM as anything but text.
+//  2. **No request leaves the machine.** An `![alt](https://…)` in an
+//     untrusted document is a tracking pixel with a caption, and a reader
+//     opening a file should not tell a third party they did. Images render as
+//     a labelled placeholder naming what they point at, which is also the
+//     honest answer for the `./diagram.png` case, where the viewer has no way
+//     to resolve a repository-relative path to something it may load.
+import { Fragment } from "react";
+import { highlight, languageFor, PLAIN_TEXT } from "../syntax/index.js";
+/**
+ * The schemes the SHELL will actually open — no wider.
+ *
+ * `javascript:` and `data:` can do more than navigate, and they are the two a
+ * link in an untrusted document would want. `mailto:` is refused for the
+ * opposite reason: the room's window-open handler passes only http(s) to the
+ * OS, so a mailto link would render as a button that does nothing, and a dead
+ * promise is worse than plain text. In-document anchors and
+ * repository-relative paths point at nothing this viewer can reach.
+ */
+function safeHref(href) {
+    const trimmed = href.trim();
+    return /^https?:\/\//i.test(trimmed) ? trimmed : null;
+}
+function InlineNodes({ nodes, renderText, }) {
+    return (_jsx(_Fragment, { children: nodes.map((node, at) => (_jsx(Fragment, { children: node.type === "text" ? (renderText === undefined ? node.value : renderText(node.value, node.source)) : node.type === "code" ? (_jsx("code", { children: node.value })) : node.type === "strong" ? (_jsx("strong", { children: _jsx(InlineNodes, { nodes: node.children, renderText: renderText }) })) : node.type === "emphasis" ? (_jsx("em", { children: _jsx(InlineNodes, { nodes: node.children, renderText: renderText }) })) : node.type === "strike" ? (_jsx("s", { children: _jsx(InlineNodes, { nodes: node.children, renderText: renderText }) })) : node.type === "break" ? (_jsx("br", {})) : node.type === "image" ? (_jsx("span", { className: "ah-md__image", title: node.src, children: node.alt === "" ? node.src : node.alt })) : (_jsx(LinkOrText, { node: node })) }, at))) }));
+}
+/** A link the shell can open, or the text it was going to be. */
+function LinkOrText({ node }) {
+    const href = safeHref(node.href);
+    if (href === null) {
+        return (_jsx("span", { className: "ah-md__deadlink", title: node.href, children: _jsx(InlineNodes, { nodes: node.children }) }));
+    }
+    // The shell's window-open handler sends http(s) to the browser; the room
+    // itself never navigates away.
+    return (_jsx("a", { href: href, target: "_blank", rel: "noreferrer", children: _jsx(InlineNodes, { nodes: node.children }) }));
+}
+function CodeFence({ language, text }) {
+    // A fence names its language the way a file name does, so the same table
+    // answers both — which is the whole reason the highlighter takes a language
+    // rather than a file.
+    const resolved = language === null ? PLAIN_TEXT : (languageFor(`x.${language}`) ?? PLAIN_TEXT);
+    const lines = highlight(text, resolved);
+    return (_jsx("pre", { className: "ah-md__code", "data-language": language ?? undefined, children: _jsx("code", { children: lines.map((line, row) => (_jsxs(Fragment, { children: [row > 0 && "\n", line.map((token, at) => token.kind === "plain" ? (_jsx(Fragment, { children: token.text }, at)) : (_jsx("span", { "data-t": token.kind, children: token.text }, at)))] }, row))) }) }));
+}
+export function MarkdownBlocks({ blocks, renderText, }) {
+    return (_jsx(_Fragment, { children: blocks.map((block, at) => {
+            switch (block.type) {
+                case "heading": {
+                    const Tag = `h${Math.min(block.level, 6)}`;
+                    return (_jsx(Tag, { children: _jsx(InlineNodes, { nodes: block.children, renderText: renderText }) }, at));
+                }
+                case "paragraph":
+                    return (_jsx("p", { children: _jsx(InlineNodes, { nodes: block.children, renderText: renderText }) }, at));
+                case "code":
+                    return _jsx(CodeFence, { language: block.language, text: block.text }, at);
+                case "quote":
+                    return (_jsx("blockquote", { children: _jsx(MarkdownBlocks, { blocks: block.children, renderText: renderText }) }, at));
+                case "rule":
+                    return _jsx("hr", {}, at);
+                case "list": {
+                    const items = block.items.map((item, index) => (_jsx("li", { children: _jsx(MarkdownBlocks, { blocks: item, renderText: renderText }) }, index)));
+                    return block.ordered ? (_jsx("ol", { start: block.start, "data-tight": block.tight ? "" : undefined, children: items }, at)) : (_jsx("ul", { "data-tight": block.tight ? "" : undefined, children: items }, at));
+                }
+                case "table":
+                    return (
+                    // A wide table scrolls inside its own box; the document's
+                    // measure is not the table's to widen.
+                    _jsx("div", { className: "ah-md__tablebox", children: _jsxs("table", { children: [_jsx("thead", { children: _jsx("tr", { children: block.head.map((cell, column) => (_jsx("th", { style: { textAlign: block.align[column] ?? undefined }, children: _jsx(InlineNodes, { nodes: cell, renderText: renderText }) }, column))) }) }), _jsx("tbody", { children: block.rows.map((row, index) => (_jsx("tr", { children: row.map((cell, column) => (_jsx("td", { style: { textAlign: block.align[column] ?? undefined }, children: _jsx(InlineNodes, { nodes: cell, renderText: renderText }) }, column))) }, index))) })] }) }, at));
+            }
+        }) }));
+}

package/dist/components/file-viewer/markdown/types.d.ts

@@ -0,0 +1,57 @@
+export type Alignment = "left" | "center" | "right" | null;
+export type Inline = {
+    readonly type: "text";
+    readonly value: string;
+    readonly source?: readonly number[];
+} | {
+    readonly type: "code";
+    readonly value: string;
+} | {
+    readonly type: "strong";
+    readonly children: readonly Inline[];
+} | {
+    readonly type: "emphasis";
+    readonly children: readonly Inline[];
+} | {
+    readonly type: "strike";
+    readonly children: readonly Inline[];
+} | {
+    readonly type: "link";
+    readonly href: string;
+    readonly children: readonly Inline[];
+} | {
+    readonly type: "image";
+    readonly src: string;
+    readonly alt: string;
+} | {
+    readonly type: "break";
+};
+export type Block = {
+    readonly type: "heading";
+    readonly level: number;
+    readonly children: readonly Inline[];
+} | {
+    readonly type: "paragraph";
+    readonly children: readonly Inline[];
+} | {
+    readonly type: "code";
+    readonly language: string | null;
+    readonly text: string;
+} | {
+    readonly type: "quote";
+    readonly children: readonly Block[];
+} | {
+    readonly type: "rule";
+} | {
+    readonly type: "list";
+    readonly ordered: boolean;
+    readonly start: number;
+    /** A list with no blank line between its items sets tighter. */
+    readonly tight: boolean;
+    readonly items: readonly (readonly Block[])[];
+} | {
+    readonly type: "table";
+    readonly head: readonly (readonly Inline[])[];
+    readonly align: readonly Alignment[];
+    readonly rows: readonly (readonly (readonly Inline[])[])[];
+};

package/dist/components/file-viewer/markdown/types.js

@@ -0,0 +1,11 @@
+// The document shape a markdown file is parsed into. A TREE, never a string
+// of HTML.
+//
+// That is a security boundary, not a style preference. A worktree is someone
+// else's repository, and a README in it is untrusted input; `marked` plus
+// `dangerouslySetInnerHTML` would let `<img src=x onerror=…>` in a checked-in
+// file run inside a renderer that holds a preload bridge. Parsing to nodes
+// and rendering them as React elements means there is no path from file
+// content to executed markup at all — raw HTML in the source is shown as the
+// text it is.
+export {};