poly-weaver 0.9.1 → 0.9.3

package/dist/markdown.js

@@ -1,7 +1,8 @@
-import { Marked } from "marked";
-import { markedTerminal } from "marked-terminal";
-import Table from "cli-table3";
 import chalk from "chalk";
+import { highlight, supportsLanguage } from "cli-highlight";
+import Table from "cli-table3";
+import MarkdownIt from "markdown-it";
+import { visibleLength } from "./ansi.js";
 import { hardWrapLine } from "./user/hard-wrap.js";
 // Force truecolor: the @xterm/headless host is not a TTY, so chalk autodetects
 // `level = 0` and emits no SGR. The host renders ANSI through its own pipeline,
@@ -10,9 +11,7 @@ chalk.level = 3;
 // OSC 8 hyperlink stripper. Form:
 //   ESC ] 8 ; params ; URL  (BEL or ESC \)  text
 //   ESC ] 8 ; ;             (BEL or ESC \)
-// Belt-and-braces sanitizer in case any renderer path (autolinks, image
-// titles, table cell links, future marked-terminal changes) leaks OSC 8 past
-// our `renderer.link` override.
+// Belt-and-braces sanitizer in case any renderer path leaks OSC 8.
 // eslint-disable-next-line no-control-regex
 const OSC8_RE = /\x1b\]8;[^\x07\x1b]*(?:\x07|\x1b\\)/g;
 const LANGUAGE_ALIASES = {
@@ -29,7 +28,7 @@ const LANGUAGE_ALIASES = {
  * `sum(colWidths) + (cols + 1)` to account for the inter-column and outer
  * borders. Each column needs at least 3 cols (1 padding + 1 char + 1 padding),
  * so when the requested width is too narrow for the column count we fall back
- * to the minimum — the table will overflow, but its internal structure stays
+ * to the minimum - the table will overflow, but its internal structure stays
  * consistent (the outer hard-wrap will still slice it).
  */
 function tableColWidths(cols, width) {
@@ -47,159 +46,44 @@ function tableColWidths(cols, width) {
     }
     return widths;
 }
-/**
- * Render markdown to an array of ANSI-styled lines fit to `width`.
- *
- * - Builds a per-call `Marked` instance so the `width` option does not leak
- *   between callers (plan pane vs. issue description use different widths).
- * - Resolves common fenced-code language aliases via `LANGUAGE_ALIASES` in a
- *   `walkTokens` hook, rewriting code token `lang` fields before
- *   marked-terminal's renderer runs.
- * - Suppresses OSC 8 hyperlinks two ways (defense-in-depth):
- *     1. Override `renderer.link` AFTER applying the marked-terminal
- *        extension. Marked's `use({ renderer })` is last-wins, so we replace
- *        the link renderer with a pure-SGR implementation. The `link` option
- *        on `markedTerminal(...)` is styling-only and runs after OSC 8 has
- *        already wrapped the text — it cannot suppress OSC 8 by itself.
- *     2. Strip any residual OSC 8 escapes from the final string.
- * - Drops stray stdout/stderr writes during marked's parse pass so renderer
- *   library warnings cannot overlay the host's alternate-screen frame.
- * - Defensively hard-wraps each output line so an over-long token (e.g.
- *   inline code with a long URL) cannot break layout.
- * - Strips the trailing blank line that marked emits after a final paragraph.
- */
-export function renderMarkdown(md, width) {
+export function renderMarkdown(md, width, options) {
+    const rows = renderMarkdownRows(md, width);
+    if (options?.withSources)
+        return rows;
+    return rows.map((row) => row.line);
+}
+function renderMarkdownRows(md, width) {
     if (md.length === 0)
         return [];
     const w = Math.max(1, width);
-    const m = new Marked();
-    m.use(markedTerminal({ width: w, reflowText: true, tab: 2 }));
-    m.use({
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        walkTokens(token) {
-            if (token.type !== "code")
-                return;
-            const lang = typeof token.lang === "string" ? token.lang.trim() : "";
-            if (lang === "")
-                return;
-            const firstWord = lang.match(/^\S+/)?.[0].toLowerCase() ?? "";
-            const resolved = LANGUAGE_ALIASES[firstWord];
-            if (resolved)
-                token.lang = resolved;
-        },
+    const parser = new MarkdownIt({
+        html: false,
+        linkify: false,
+        typographer: false,
     });
-    m.use({
-        renderer: {
-            link({ href, tokens }) {
-                // `this.parser.parseInline(tokens)` re-renders the link's child tokens
-                // with the active renderer chain (so any inline emphasis/code keeps
-                // its styling) but as plain SGR, not OSC 8.
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const text = this.parser.parseInline(tokens);
-                return chalk.cyan.underline(text) + " " + chalk.dim(`(${href})`);
-            },
-            // Override marked-terminal's table renderer. The upstream version passes
-            // no width hint to cli-table3, which then auto-sizes columns to the
-            // longest cell — long cells produce tables wider than the pane, and our
-            // outer hard-wrap slices each row mid-border (orphaned `│` + trailing
-            // `─`s on the next visual line). Compute `colWidths` to fit `w` and let
-            // cli-table3's `wordWrap` handle long content cleanly.
-            table({ header, rows,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-             }) {
-                const cols = header.length;
-                if (cols === 0)
-                    return "";
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const parser = this.parser;
-                const head = header.map((c) => parser.parseInline(c.tokens));
-                const body = rows.map((row) => row.map((c) => parser.parseInline(c.tokens)));
-                const t = new Table({
-                    head,
-                    colWidths: tableColWidths(cols, w),
-                    wordWrap: true,
-                    wrapOnWordBoundary: false,
-                });
-                for (const row of body)
-                    t.push(row);
-                return t.toString() + "\n\n";
-            },
-            list(token) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const parser = this.parser;
-                const startNum = typeof token.start === "number" ? token.start : 1;
-                let out = "";
-                for (let i = 0; i < token.items.length; i++) {
-                    const item = token.items[i];
-                    let prefix;
-                    let prefixWidth;
-                    if (item.task) {
-                        prefix = (item.checked ? chalk.green("☒") : chalk.dim("☐")) + " ";
-                        prefixWidth = 2;
-                    }
-                    else if (token.ordered) {
-                        const raw = `${startNum + i}. `;
-                        prefix = chalk.dim(raw);
-                        prefixWidth = raw.length;
-                    }
-                    else {
-                        prefix = chalk.dim("•") + " ";
-                        prefixWidth = 2;
-                    }
-                    let body = parser.parse(item.tokens, !!item.loose);
-                    body = body.replace(/\n+$/, "");
-                    const indent = " ".repeat(prefixWidth);
-                    const lines = body.split("\n");
-                    out += prefix + lines[0] + "\n";
-                    for (let k = 1; k < lines.length; k++) {
-                        out += indent + lines[k] + "\n";
-                    }
-                }
-                return out + "\n";
-            },
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            listitem(item) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return this.parser.parse(item.tokens, !!item.loose);
-            },
-            // marked-terminal's `text` renderer returns `token.text` raw, dropping
-            // inline children. Restore marked v15's default behavior of dispatching
-            // `token.tokens` through `parseInline` so inline markup (links, code,
-            // bold, italic) inside tight list items is styled by our renderer chain.
-            //
-            // Also preserve a trailing newline from `token.raw`: in marked v15, the
-            // lexer keeps a trailing `\n` on a text token's raw when a block element
-            // follows (e.g. a nested list under a tight item). Block-level
-            // `parser.parse(tokens, false)` concatenates token outputs without
-            // inserting separators, so without that newline our list item body
-            // would glue "parent" directly to the nested "• child".
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            text(token) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const out = token.tokens
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    ? this.parser.parseInline(token.tokens)
-                    : token.text;
-                return typeof token.raw === "string" && token.raw.endsWith("\n")
-                    ? out + "\n"
-                    : out;
-            },
-        },
+    const rows = silenceRendererOutput(() => {
+        const tokens = parser.parse(md, {});
+        return renderBlocks(tokens, 0, tokens.length, {
+            width: w,
+            topLevel: true,
+        });
     });
+    return finalizeRows(rows, w);
+}
+function silenceRendererOutput(fn) {
     const originalConsoleLog = console.log;
     const originalConsoleError = console.error;
     const originalConsoleWarn = console.warn;
     const originalStdoutWrite = process.stdout.write;
     const originalStderrWrite = process.stderr.write;
     const noopWrite = (() => true);
-    let raw;
     try {
         console.log = () => { };
         console.error = () => { };
         console.warn = () => { };
         process.stdout.write = noopWrite;
         process.stderr.write = noopWrite;
-        raw = m.parse(md);
+        return fn();
     }
     finally {
         console.log = originalConsoleLog;
@@ -208,15 +92,500 @@ export function renderMarkdown(md, width) {
         process.stdout.write = originalStdoutWrite;
         process.stderr.write = originalStderrWrite;
     }
-    const sanitized = raw.replace(OSC8_RE, "");
-    const split = sanitized.split(/\r?\n/);
-    while (split.length > 0 && split[split.length - 1] === "")
-        split.pop();
+}
+function renderBlocks(tokens, start, end, ctx) {
+    const rows = [];
+    let index = start;
+    let emittedBlock = false;
+    while (index < end) {
+        const result = renderBlock(tokens, index, end, ctx);
+        if (result.next <= index) {
+            index++;
+            continue;
+        }
+        index = result.next;
+        if (result.rows.length === 0)
+            continue;
+        if (ctx.topLevel && emittedBlock) {
+            rows.push({ line: "", source: undefined });
+        }
+        rows.push(...result.rows);
+        emittedBlock = true;
+    }
+    return rows;
+}
+function renderBlock(tokens, index, end, ctx) {
+    const token = tokens[index];
+    switch (token.type) {
+        case "heading_open":
+            return renderHeading(tokens, index, ctx);
+        case "paragraph_open":
+            return renderParagraph(tokens, index, ctx);
+        case "hr":
+            return {
+                rows: [{ line: chalk.dim("─".repeat(ctx.width)), source: sourceFromMap(token.map) }],
+                next: index + 1,
+            };
+        case "fence":
+            return {
+                rows: renderFence(token),
+                next: index + 1,
+            };
+        case "code_block":
+            return {
+                rows: renderIndentedCode(token),
+                next: index + 1,
+            };
+        case "blockquote_open":
+            return renderBlockquote(tokens, index, ctx);
+        case "bullet_list_open":
+        case "ordered_list_open":
+            return renderList(tokens, index, ctx);
+        case "table_open":
+            return renderTable(tokens, index, ctx);
+        case "html_block":
+            return renderHtmlBlock(token, index);
+        default:
+            return { rows: [], next: index + 1 };
+    }
+}
+function renderHeading(tokens, index, ctx) {
+    const open = tokens[index];
+    const close = findMatchingClose(tokens, index);
+    const inline = tokens[index + 1]?.type === "inline" ? tokens[index + 1] : undefined;
+    const text = inline ? renderInline(inline.children ?? []) : "";
+    const level = Number.parseInt(open.tag.slice(1), 10);
+    const heading = `${"#".repeat(level)} ${text}`;
+    const styled = level === 1
+        ? chalk.magenta.underline.bold(heading)
+        : chalk.green.bold(heading);
+    return {
+        rows: wrapStyledText(styled, ctx.width).map((line) => ({
+            line,
+            source: sourceFromMap(open.map),
+        })),
+        next: close + 1,
+    };
+}
+function renderParagraph(tokens, index, ctx) {
+    const open = tokens[index];
+    const close = findMatchingClose(tokens, index);
+    const parts = [];
+    for (let i = index + 1; i < close; i++) {
+        const token = tokens[i];
+        if (token.type === "inline") {
+            parts.push(renderInline(token.children ?? []));
+        }
+        else if (token.content) {
+            parts.push(token.content);
+        }
+    }
+    const source = sourceFromMap(open.map);
+    return {
+        rows: wrapStyledText(parts.join(""), ctx.width).map((line) => ({
+            line,
+            source,
+        })),
+        next: close + 1,
+    };
+}
+function renderFence(token) {
+    if (token.content.length === 0)
+        return [];
+    const highlighted = highlightCode(token.content, token.info);
+    const withoutFinalNewline = highlighted.endsWith("\n")
+        ? highlighted.slice(0, -1)
+        : highlighted;
+    const lines = withoutFinalNewline.split("\n");
+    const rows = [];
+    const mapStart = token.map?.[0];
+    for (let i = 0; i < lines.length; i++) {
+        const sourceLine = mapStart === undefined ? undefined : mapStart + 2 + i;
+        rows.push({
+            line: `  ${lines[i]}`,
+            source: sourceLine === undefined
+                ? undefined
+                : { start: sourceLine, end: sourceLine },
+        });
+    }
+    return rows;
+}
+function renderIndentedCode(token) {
+    if (token.content.length === 0)
+        return [];
+    const withoutFinalNewline = token.content.endsWith("\n")
+        ? token.content.slice(0, -1)
+        : token.content;
+    const lines = withoutFinalNewline.split("\n");
+    const rows = [];
+    const mapStart = token.map?.[0];
+    for (let i = 0; i < lines.length; i++) {
+        const sourceLine = mapStart === undefined ? undefined : mapStart + 1 + i;
+        rows.push({
+            line: `  ${lines[i]}`,
+            source: sourceLine === undefined
+                ? undefined
+                : { start: sourceLine, end: sourceLine },
+        });
+    }
+    return rows;
+}
+function renderBlockquote(tokens, index, ctx) {
+    const open = tokens[index];
+    const close = findMatchingClose(tokens, index);
+    const prefix = `${chalk.dim("│")} `;
+    const prefixWidth = visibleLength(prefix);
+    const source = sourceFromMap(open.map);
+    const innerRows = renderBlocks(tokens, index + 1, close, {
+        width: Math.max(1, ctx.width - prefixWidth),
+        topLevel: false,
+        outerListSource: ctx.outerListSource,
+    });
+    return {
+        rows: innerRows.map((row) => ({
+            line: `${prefix}${row.line}`,
+            source,
+        })),
+        next: close + 1,
+    };
+}
+function renderList(tokens, index, ctx) {
+    const open = tokens[index];
+    const close = findMatchingClose(tokens, index);
+    const source = ctx.outerListSource ?? sourceFromMap(open.map);
+    const rows = [];
+    const loose = isLooseList(tokens, index + 1, close);
+    let itemIndex = index + 1;
+    let ordinal = orderedListStart(open);
+    let renderedItems = 0;
+    while (itemIndex < close) {
+        const itemOpen = tokens[itemIndex];
+        if (itemOpen.type !== "list_item_open") {
+            itemIndex++;
+            continue;
+        }
+        const itemClose = findMatchingClose(tokens, itemIndex);
+        const childTokens = tokens
+            .slice(itemIndex + 1, itemClose)
+            .map((token) => cloneToken(token));
+        const task = stripLeadingTaskMarker(childTokens);
+        const marker = listMarker(open, ordinal, task);
+        const markerWidth = visibleLength(marker);
+        const innerRows = renderBlocks(childTokens, 0, childTokens.length, {
+            width: Math.max(1, ctx.width - markerWidth),
+            topLevel: false,
+            outerListSource: source,
+        });
+        const itemRows = innerRows.length > 0
+            ? innerRows
+            : [{ line: "", source }];
+        rows.push({
+            line: `${marker}${itemRows[0].line}`,
+            source,
+        });
+        const indent = " ".repeat(markerWidth);
+        for (let i = 1; i < itemRows.length; i++) {
+            rows.push({
+                line: `${indent}${itemRows[i].line}`,
+                source,
+            });
+        }
+        itemIndex = itemClose + 1;
+        renderedItems++;
+        ordinal++;
+        if (loose && hasMoreListItems(tokens, itemIndex, close)) {
+            rows.push({ line: "", source });
+        }
+    }
+    return {
+        rows: renderedItems > 0 ? rows : [],
+        next: close + 1,
+    };
+}
+function renderTable(tokens, index, ctx) {
+    const open = tokens[index];
+    const close = findMatchingClose(tokens, index);
+    const source = sourceFromMap(open.map);
+    const header = [];
+    const body = [];
+    let currentRow;
+    let inHead = false;
+    let inBody = false;
+    for (let i = index + 1; i < close; i++) {
+        const token = tokens[i];
+        switch (token.type) {
+            case "thead_open":
+                inHead = true;
+                break;
+            case "thead_close":
+                inHead = false;
+                break;
+            case "tbody_open":
+                inBody = true;
+                break;
+            case "tbody_close":
+                inBody = false;
+                break;
+            case "tr_open":
+                currentRow = [];
+                break;
+            case "tr_close":
+                if (currentRow) {
+                    if (inHead)
+                        header.push(...currentRow);
+                    else if (inBody)
+                        body.push(currentRow);
+                }
+                currentRow = undefined;
+                break;
+            case "inline":
+                currentRow?.push(renderInline(token.children ?? []));
+                break;
+        }
+    }
+    if (header.length === 0) {
+        return { rows: [], next: close + 1 };
+    }
+    const table = new Table({
+        head: header,
+        colWidths: tableColWidths(header.length, ctx.width),
+        wordWrap: true,
+        wrapOnWordBoundary: false,
+    });
+    for (const row of body)
+        table.push(row);
+    return {
+        rows: table.toString().split(/\r?\n/).map((line) => ({ line, source })),
+        next: close + 1,
+    };
+}
+function renderHtmlBlock(token, index) {
+    const source = sourceFromMap(token.map);
+    const content = token.content.endsWith("\n")
+        ? token.content.slice(0, -1)
+        : token.content;
+    return {
+        rows: content.split(/\r?\n/).map((line) => ({ line, source })),
+        next: index + 1,
+    };
+}
+function renderInline(tokens) {
+    let out = "";
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        switch (token.type) {
+            case "text":
+                out += token.content;
+                break;
+            case "code_inline":
+                out += chalk.yellow(token.content);
+                break;
+            case "softbreak":
+                out += " ";
+                break;
+            case "hardbreak":
+                out += "\n";
+                break;
+            case "strong_open": {
+                const close = findInlineClose(tokens, i, "strong_open", "strong_close");
+                out += chalk.bold(renderInline(tokens.slice(i + 1, close)));
+                i = close;
+                break;
+            }
+            case "em_open": {
+                const close = findInlineClose(tokens, i, "em_open", "em_close");
+                out += chalk.italic(renderInline(tokens.slice(i + 1, close)));
+                i = close;
+                break;
+            }
+            case "link_open": {
+                const close = findInlineClose(tokens, i, "link_open", "link_close");
+                const text = renderInline(tokens.slice(i + 1, close));
+                const href = token.attrGet("href") ?? "";
+                out += chalk.cyan.underline(text) + " " + chalk.dim(`(${href})`);
+                i = close;
+                break;
+            }
+            case "image":
+                out += token.content;
+                break;
+            case "html_inline":
+                out += token.content;
+                break;
+            default:
+                if (token.children)
+                    out += renderInline(token.children);
+                else
+                    out += token.content;
+                break;
+        }
+    }
+    return out;
+}
+function highlightCode(code, info) {
+    const language = resolveLanguage(info);
+    if (!language || !supportsLanguage(language))
+        return code;
+    try {
+        return highlight(code, {
+            language,
+            ignoreIllegals: true,
+        });
+    }
+    catch {
+        return code;
+    }
+}
+function resolveLanguage(info) {
+    const firstWord = info.trim().match(/^\S+/)?.[0].toLowerCase();
+    if (!firstWord)
+        return undefined;
+    return LANGUAGE_ALIASES[firstWord] ?? firstWord;
+}
+function listMarker(listOpen, ordinal, task) {
+    if (task)
+        return (task.checked ? chalk.green("☒") : chalk.dim("☐")) + " ";
+    if (listOpen.type === "ordered_list_open")
+        return chalk.dim(`${ordinal}. `);
+    return chalk.dim("•") + " ";
+}
+function orderedListStart(token) {
+    const attr = token.attrGet("start");
+    if (attr) {
+        const parsed = Number.parseInt(attr, 10);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return 1;
+}
+function stripLeadingTaskMarker(tokens) {
+    for (const token of tokens) {
+        if (token.type !== "inline")
+            continue;
+        const match = token.content.match(/^\[([ xX])\][ \t]+/);
+        if (!match)
+            return undefined;
+        stripInlinePrefix(token, match[0].length);
+        return { checked: match[1].toLowerCase() === "x" };
+    }
+    return undefined;
+}
+function stripInlinePrefix(token, length) {
+    token.content = token.content.slice(length);
+    let remaining = length;
+    for (const child of token.children ?? []) {
+        if (remaining <= 0)
+            break;
+        if (child.type !== "text")
+            continue;
+        const take = Math.min(remaining, child.content.length);
+        child.content = child.content.slice(take);
+        remaining -= take;
+    }
+}
+function isLooseList(tokens, start, end) {
+    for (let i = start; i < end; i++) {
+        if (tokens[i].type === "paragraph_open" && !tokens[i].hidden)
+            return true;
+    }
+    return false;
+}
+function hasMoreListItems(tokens, start, end) {
+    for (let i = start; i < end; i++) {
+        if (tokens[i].type === "list_item_open")
+            return true;
+    }
+    return false;
+}
+function wrapStyledText(text, width) {
+    if (width < 1)
+        width = 1;
+    if (text.length === 0)
+        return [""];
     const out = [];
-    for (const line of split) {
-        for (const wrapped of hardWrapLine(line, w))
-            out.push(wrapped);
+    for (const paragraph of text.split("\n")) {
+        const words = paragraph.split(/\s+/).filter((word) => word.length > 0);
+        if (words.length === 0) {
+            out.push("");
+            continue;
+        }
+        let line = "";
+        for (const word of words) {
+            const separator = line.length === 0 ? "" : " ";
+            if (visibleLength(word) > width) {
+                if (line.length > 0) {
+                    out.push(line);
+                    line = "";
+                }
+                const chunks = hardWrapLine(word, width);
+                out.push(...chunks.slice(0, -1));
+                line = chunks[chunks.length - 1] ?? "";
+                continue;
+            }
+            if (line.length > 0 &&
+                visibleLength(line) + 1 + visibleLength(word) > width) {
+                out.push(line);
+                line = word;
+            }
+            else {
+                line += separator + word;
+            }
+        }
+        if (line.length > 0)
+            out.push(line);
     }
+    return out.length > 0 ? out : [""];
+}
+function finalizeRows(rows, width) {
+    const out = [];
+    for (const row of rows) {
+        const sanitized = row.line.replace(OSC8_RE, "");
+        for (const line of hardWrapLine(sanitized, width)) {
+            out.push({ line: line.replace(OSC8_RE, ""), source: row.source });
+        }
+    }
+    while (out.length > 0 && out[out.length - 1].line === "")
+        out.pop();
     return out;
 }
+function sourceFromMap(map) {
+    if (!map)
+        return undefined;
+    return { start: map[0] + 1, end: map[1] };
+}
+function findMatchingClose(tokens, openIndex) {
+    const openType = tokens[openIndex].type;
+    const closeType = openType.replace(/_open$/, "_close");
+    let depth = 0;
+    for (let i = openIndex; i < tokens.length; i++) {
+        if (tokens[i].type === openType)
+            depth++;
+        else if (tokens[i].type === closeType) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return openIndex;
+}
+function findInlineClose(tokens, openIndex, openType, closeType) {
+    let depth = 0;
+    for (let i = openIndex; i < tokens.length; i++) {
+        if (tokens[i].type === openType)
+            depth++;
+        else if (tokens[i].type === closeType) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return openIndex;
+}
+function cloneToken(token) {
+    const clone = Object.create(Object.getPrototypeOf(token));
+    Object.assign(clone, token);
+    if (token.children)
+        clone.children = token.children.map((child) => cloneToken(child));
+    return clone;
+}
 //# sourceMappingURL=markdown.js.map