@code-yeongyu/senpi-tui 2026.11.11 → 2026.11.13

package/dist/components/markdown.js

@@ -1,9 +1,12 @@
 // allow: SIZE_OK - existing markdown renderer is oversized; this merge only preserves behavior and cache-key correctness.
 import { Marked, Tokenizer } from "marked";
+import { copyLineSources, getLineSources, setLineSource, setLineSources, } from "../selection-source.js";
+import { concatRanges, emptyRanges, rangeAt, repeatedRange, sliceRanges } from "../source-ranges.js";
 import { getCapabilities, hyperlink, isImageLine } from "../terminal-image.js";
 import { nextRenderRevision } from "../tui.js";
-import { applyBackgroundToLine, flattenLines, visibleWidth, wrapTextWithAnsi } from "../utils.js";
+import { applyBackgroundToLine, flattenLines, stripTerminalSequences, visibleWidth, wrapTextWithAnsi, } from "../utils.js";
 import { latexToUnicode } from "./latex.js";
+import { lexWithSources, sourceExtensions, tokenSource } from "./markdown-source.js";
 const STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
 class StrictStrikethroughTokenizer extends Tokenizer {
     del(src) {
@@ -31,6 +34,24 @@ function isLatexToken(token) {
         "text" in token &&
         typeof token.text === "string");
 }
+function formulaRanges(token, rendered) {
+    const source = tokenSource(token);
+    if (!source)
+        return repeatedRange(null, rendered.length);
+    const { raw, text } = source;
+    const end = raw.text.trimEnd().length;
+    if (raw.text === rendered)
+        return raw.ranges;
+    if (raw.text.trim() === rendered) {
+        return sliceRanges(raw.ranges, raw.text.length - raw.text.trimStart().length, end);
+    }
+    if (text?.text === rendered)
+        return text.ranges;
+    // A converted glyph has no reliable character-level correspondence to TeX.
+    const first = rangeAt(raw.ranges, 0);
+    const last = rangeAt(raw.ranges, end - 1);
+    return repeatedRange(first && last ? { start: first.start, end: last.end } : null, rendered.length);
+}
 function previousRawCharacter(tokens) {
     const raw = tokens[tokens.length - 1]?.raw;
     return raw ? Array.from(raw).at(-1) : undefined;
@@ -264,20 +285,26 @@ function trimPartialClosingFences(tokens) {
 }
 const markdownParser = new Marked();
 markdownParser.use({ extensions: [blockMathTokenizer, inlineMathTokenizer] });
+markdownParser.use({ extensions: sourceExtensions });
 markdownParser.setOptions({
     tokenizer: new StrictStrikethroughTokenizer(),
 });
 const RENDER_CACHE_MAX = 256;
 const PARSE_CACHE_MAX = 128;
+// Original-source work is paid only on copy, with a small cache separate from normal rendering.
+const SOURCE_CACHE_MAX = 8;
 const CONTENT_KEY_CACHE_MAX = 128;
 const HIGHLIGHT_CACHE_MAX = 512;
 const MAX_HIGHLIGHT_BYTES = 200_000;
 const MAX_HIGHLIGHT_LINES = 2000;
 const renderCache = new Map();
 const parseCache = new Map();
+const sourceRenderCache = new Map();
+const sourceParseCache = new Map();
 const contentKeyCache = new Map();
 const highlightCache = new Map();
 const objectIds = new WeakMap();
+const enclosedTokens = new WeakSet();
 let nextObjectId = 0;
 let markdownHighlightCallCount = 0;
 function objectId(value) {
@@ -316,6 +343,8 @@ function contentKey(text) {
 export function clearRenderCache() {
     renderCache.clear();
     parseCache.clear();
+    sourceRenderCache.clear();
+    sourceParseCache.clear();
     contentKeyCache.clear();
     highlightCache.clear();
 }
@@ -327,6 +356,7 @@ export function resetMarkdownHighlightCallCount() {
 }
 export class Markdown {
     constructor(text, paddingX, paddingY, theme, defaultTextStyle, options) {
+        this.collectSources = false;
         this.revision = nextRenderRevision();
         this.text = text;
         this.paddingX = paddingX;
@@ -343,6 +373,7 @@ export class Markdown {
         this.cachedText = undefined;
         this.cachedWidth = undefined;
         this.cachedLines = undefined;
+        this.activeSourceDocument = undefined;
         this.markRevision();
     }
     /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
@@ -370,12 +401,10 @@ export class Markdown {
             this.cachedLines = result;
             return result;
         }
-        // Replace tabs with 3 spaces for consistent rendering
-        const normalizedText = text.replace(/\t/g, "   ");
-        const normalizedContentKey = contentKey(normalizedText);
         const styleKey = this.defaultTextStyle ? objectId(this.defaultTextStyle) : -1;
         const renderKey = [
-            normalizedContentKey,
+            contentKey(this.text),
+            contentKey(text),
             width,
             contentWidth,
             this.paddingX,
@@ -389,44 +418,62 @@ export class Markdown {
             getCapabilities().images ?? "",
             getCapabilities().hyperlinks ? 1 : 0,
         ].join("\x00");
-        const cachedRender = renderCache.get(renderKey);
-        if (cachedRender?.source === normalizedText) {
+        const selectedRenderCache = this.collectSources ? sourceRenderCache : renderCache;
+        const cachedRender = selectedRenderCache.get(renderKey);
+        if (cachedRender?.source === this.text && cachedRender.transformed === text) {
             this.cachedText = this.text;
             this.cachedWidth = width;
-            this.cachedLines = cachedRender.lines;
-            return cachedRender.lines;
+            this.cachedLines = this.ownSources(cachedRender.lines);
+            return this.cachedLines;
         }
         // Parse markdown to HTML-like tokens
-        const cachedParse = parseCache.get(normalizedContentKey);
+        const parseKey = contentKey(text);
+        const selectedParseCache = this.collectSources ? sourceParseCache : parseCache;
+        const cachedParse = selectedParseCache.get(parseKey);
         let tokens;
-        if (cachedParse?.source === normalizedText) {
+        if (cachedParse?.source === text) {
             tokens = cachedParse.tokens;
         }
         else {
-            tokens = markdownParser.lexer(normalizedText);
+            tokens = this.collectSources
+                ? lexWithSources(text, markdownParser.defaults)
+                : markdownParser.lexer(text.replace(/\t/g, "   "));
             trimPartialClosingFences(tokens);
-            cacheSet(parseCache, normalizedContentKey, { source: normalizedText, tokens }, PARSE_CACHE_MAX);
+            cacheSet(selectedParseCache, parseKey, { source: text, tokens }, this.collectSources ? SOURCE_CACHE_MAX : PARSE_CACHE_MAX);
         }
         // Convert tokens to styled terminal output
+        this.activeSourceDocument = this.collectSources
+            ? (tokens.map((token) => tokenSource(token)?.raw.document).find((document) => document) ?? {
+                text,
+                enclosures: [],
+            })
+            : undefined;
         const renderedLines = [];
         for (let i = 0; i < tokens.length; i++) {
             const token = tokens[i];
             const nextToken = tokens[i + 1];
             const tokenLines = this.renderToken(token, contentWidth, nextToken?.type);
+            const offset = renderedLines.length;
             for (const tokenLine of tokenLines) {
                 renderedLines.push(tokenLine);
             }
+            copyLineSources(tokenLines, renderedLines, offset);
         }
         // Wrap lines (NO padding, NO background yet)
         const wrappedLines = [];
-        for (const line of renderedLines) {
+        for (let row = 0; row < renderedLines.length; row++) {
+            const line = renderedLines[row];
+            const mapping = getLineSources(renderedLines)?.[row];
+            const offset = wrappedLines.length;
             if (isImageLine(line)) {
                 wrappedLines.push(line);
             }
             else {
-                for (const wrappedLine of wrapTextWithAnsi(line, contentWidth)) {
+                const fragments = this.wrapSource(line, contentWidth, mapping);
+                for (const wrappedLine of fragments) {
                     wrappedLines.push(wrappedLine);
                 }
+                copyLineSources(fragments, wrappedLines, offset);
             }
         }
         // Add margins and background to each wrapped line
@@ -450,6 +497,7 @@ export class Markdown {
                 contentLines.push(lineWithMargins + " ".repeat(paddingNeeded));
             }
         }
+        copyLineSources(wrappedLines, contentLines, 0, this.paddingX);
         // Add top/bottom padding (empty lines)
         const emptyLine = " ".repeat(width);
         const emptyLines = [];
@@ -459,13 +507,117 @@ export class Markdown {
         }
         // Combine top padding, content, and bottom padding
         const result = emptyLines.concat(contentLines, emptyLines);
+        copyLineSources(contentLines, result, this.paddingY);
+        const mapped = getLineSources(result);
+        const document = mapped?.find((line) => line)?.document;
+        if (document) {
+            setLineSources(result, result.map((_, row) => mapped?.[row] ?? { document, ranges: emptyRanges }));
+        }
+        if (text !== this.text) {
+            const transformedDocument = { text: this.text, enclosures: [] };
+            setLineSources(result, result.map(() => ({ document: transformedDocument, ranges: emptyRanges, renderedFallback: true })));
+        }
+        else if (!this.collectSources) {
+            // Capture values, not this component. Old cached frames must retain their own source.
+            const sourceText = this.text;
+            const { paddingX, paddingY, theme, defaultTextStyle } = this;
+            const options = { ...this.options, transform: undefined };
+            const deferred = {
+                text: sourceText,
+                enclosures: [],
+                resolveLines: () => {
+                    const markdown = new Markdown(sourceText, paddingX, paddingY, theme, defaultTextStyle, options);
+                    markdown.collectSources = true;
+                    const sourceLines = markdown.render(width);
+                    if (sourceLines.length !== result.length || sourceLines.some((line, row) => line !== result[row])) {
+                        return undefined;
+                    }
+                    return getLineSources(sourceLines);
+                },
+            };
+            setLineSources(result, result.map((_, sourceRow) => ({
+                document: deferred,
+                ranges: emptyRanges,
+                sourceRow,
+            })));
+        }
         flattenLines(result);
         // Update cache
         this.cachedText = this.text;
         this.cachedWidth = width;
-        this.cachedLines = result;
-        cacheSet(renderCache, renderKey, { source: normalizedText, lines: result }, RENDER_CACHE_MAX);
-        return result.length > 0 ? result : [""];
+        this.cachedLines = this.ownSources(result);
+        cacheSet(selectedRenderCache, renderKey, { source: this.text, transformed: text, lines: result }, this.collectSources ? SOURCE_CACHE_MAX : RENDER_CACHE_MAX);
+        return this.cachedLines.length > 0 ? this.cachedLines : [""];
+    }
+    /** Shared render caches must not make two separate messages one source interval. */
+    ownSources(lines) {
+        const mapping = getLineSources(lines);
+        if (!mapping)
+            return lines;
+        const original = mapping.find((line) => line)?.document;
+        if (!original)
+            return lines;
+        const document = { ...original };
+        const result = [...lines];
+        setLineSources(result, mapping.map((line) => line && { ...line, document }));
+        return result;
+    }
+    wrapSource(text, width, source) {
+        const mapping = [];
+        const lines = wrapTextWithAnsi(text, width, source
+            ? (start, end) => {
+                mapping.push({ ...source, ranges: sliceRanges(source.ranges, start, end) });
+            }
+            : undefined);
+        if (source === null)
+            setLineSources(lines, lines.map(() => null));
+        else if (source)
+            setLineSources(lines, mapping);
+        return lines;
+    }
+    enclose(token, ranges) {
+        if (![
+            "heading",
+            "strong",
+            "em",
+            "del",
+            "codespan",
+            "code",
+            "link",
+            "image",
+            "escape",
+            "latex_inline",
+            "latex_block",
+            "table",
+            "blockquote",
+        ].includes(token.type))
+            return;
+        if (enclosedTokens.has(token))
+            return;
+        const source = tokenSource(token)?.raw;
+        if (!source)
+            return;
+        const rawEnd = token.type === "latex_block" ? source.text.trimEnd().length : source.text.replace(/\n+$/, "").length;
+        const start = rangeAt(source.ranges, 0)?.start;
+        const end = rangeAt(source.ranges, rawEnd - 1)?.end;
+        if (start === undefined || end === undefined)
+            return;
+        let contentStart = Infinity;
+        let contentEnd = 0;
+        for (const { source: range } of ranges.spans) {
+            if (!range)
+                continue;
+            contentStart = Math.min(contentStart, range.start);
+            contentEnd = Math.max(contentEnd, range.end);
+        }
+        if (contentStart === Infinity)
+            return;
+        enclosedTokens.add(token);
+        source.document.enclosures.push({
+            start,
+            end,
+            content: { start: contentStart, end: contentEnd },
+        });
     }
     /**
      * Apply default text style to a string.
@@ -583,6 +735,8 @@ export class Markdown {
     }
     renderToken(token, width, nextTokenType, styleContext) {
         const lines = [];
+        const inlineRanges = this.collectSources ? [] : undefined;
+        const source = tokenSource(token);
         switch (token.type) {
             case "heading": {
                 const headingLevel = token.depth;
@@ -601,8 +755,26 @@ export class Markdown {
                     applyText: headingStyleFn,
                     stylePrefix: this.getStylePrefix(headingStyleFn),
                 };
-                const headingText = this.renderInlineTokens(token.tokens || [], headingStyleContext);
+                const headingText = this.renderInlineTokens(token.tokens || [], headingStyleContext, inlineRanges);
                 const styledHeading = headingLevel >= 3 ? headingStyleFn(headingPrefix) + headingText : headingText;
+                if (headingLevel >= 3 && inlineRanges) {
+                    const prefix = /^( {0,3})(#{3,6})([ \t]*)/.exec(source?.raw.text ?? "");
+                    if (source && prefix) {
+                        const start = prefix[1].length;
+                        const end = start + prefix[2].length;
+                        const separatorStart = rangeAt(source.raw.ranges, end);
+                        const separatorEnd = rangeAt(source.raw.ranges, end + prefix[3].length - 1);
+                        inlineRanges.unshift(concatRanges([
+                            sliceRanges(source.raw.ranges, start, end),
+                            repeatedRange(prefix[3].length && separatorStart && separatorEnd
+                                ? { start: separatorStart.start, end: separatorEnd.end }
+                                : undefined, 1),
+                        ]));
+                    }
+                    else {
+                        inlineRanges.unshift(repeatedRange(undefined, headingPrefix.length));
+                    }
+                }
                 lines.push(styledHeading);
                 if (nextTokenType && nextTokenType !== "space") {
                     lines.push(""); // Add spacing after headings (unless space token follows)
@@ -610,7 +782,7 @@ export class Markdown {
                 break;
             }
             case "paragraph": {
-                const paragraphText = this.renderInlineTokens(token.tokens || [], styleContext);
+                const paragraphText = this.renderInlineTokens(token.tokens || [], styleContext, inlineRanges);
                 lines.push(paragraphText);
                 // Don't add spacing if next token is space or list
                 if (nextTokenType && nextTokenType !== "list" && nextTokenType !== "space") {
@@ -622,17 +794,64 @@ export class Markdown {
                 if (isLatexToken(token)) {
                     const formula = this.options.renderLatex === false ? token.raw.trim() : latexToUnicode(token.text);
                     lines.push(styleContext ? styleContext.applyText(formula) : this.applyDefaultStyle(formula));
+                    if (inlineRanges)
+                        inlineRanges.push(formulaRanges(token, stripTerminalSequences(lines[0])));
                     if (nextTokenType && nextTokenType !== "space") {
                         lines.push("");
                     }
                 }
                 break;
             case "text":
-                lines.push(this.renderInlineTokens([token], styleContext));
+                lines.push(this.renderInlineTokens([token], styleContext, inlineRanges));
                 break;
             case "code": {
                 const indent = this.theme.codeBlockIndent ?? "  ";
                 this.renderCodeBlock(lines, token.text, token.lang, indent);
+                if (source?.text) {
+                    const ranges = [];
+                    let offset = 0;
+                    const openingLength = /^[^\n]*/.exec(source.raw.text)?.[0].length ?? 0;
+                    const openingStart = rangeAt(source.raw.ranges, 0);
+                    const openingEnd = rangeAt(source.raw.ranges, openingLength - 1);
+                    const open = token.codeBlockStyle !== "indented" && openingStart && openingEnd
+                        ? { start: openingStart.start, end: openingEnd.end }
+                        : undefined;
+                    ranges.push({
+                        document: source.raw.document,
+                        ranges: repeatedRange(open, stripTerminalSequences(lines[0]).length),
+                    });
+                    const codeLines = token.text.split("\n");
+                    for (let row = 1; row < lines.length - 1; row++) {
+                        const codeLine = codeLines[row - 1] ?? "";
+                        const rendered = stripTerminalSequences(lines[row]).slice(indent.length);
+                        ranges.push({
+                            document: source.raw.document,
+                            ranges: concatRanges([
+                                repeatedRange(undefined, indent.length),
+                                rendered === codeLine
+                                    ? sliceRanges(source.text.ranges, offset, offset + codeLine.length)
+                                    : repeatedRange(null, rendered.length),
+                            ]),
+                        });
+                        offset += codeLine.length + 1;
+                    }
+                    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(source.raw.text)?.[1];
+                    const closing = marker
+                        ? new RegExp(`\\n( {0,3}${marker[0]}{${marker.length},}[ \\t]*)\\n?$`).exec(source.raw.text)
+                        : null;
+                    const closeRanges = closing
+                        ? sliceRanges(source.raw.ranges, closing.index + (closing[0].startsWith("\n") ? 1 : 0), source.raw.text.trimEnd().length)
+                        : emptyRanges;
+                    const closingStart = rangeAt(closeRanges, 0);
+                    const closingEnd = rangeAt(closeRanges, closeRanges.length - 1);
+                    const close = closingStart && closingEnd ? { start: closingStart.start, end: closingEnd.end } : undefined;
+                    ranges.push({
+                        document: source.raw.document,
+                        ranges: repeatedRange(close, stripTerminalSequences(lines[lines.length - 1]).length),
+                    });
+                    setLineSources(lines, ranges);
+                    this.enclose(token, concatRanges(ranges.map((line) => line.ranges)));
+                }
                 if (nextTokenType && nextTokenType !== "space") {
                     lines.push(""); // Add spacing after code blocks (unless space token follows)
                 }
@@ -641,6 +860,7 @@ export class Markdown {
             case "list": {
                 const listLines = this.renderList(token, 0, width, styleContext);
                 lines.push(...listLines);
+                copyLineSources(listLines, lines);
                 // Don't add spacing after lists if a space token follows
                 // (the space token will handle it)
                 break;
@@ -648,6 +868,7 @@ export class Markdown {
             case "table": {
                 const tableLines = this.renderTable(token, width, nextTokenType, styleContext);
                 lines.push(...tableLines);
+                copyLineSources(tableLines, lines);
                 break;
             }
             case "blockquote": {
@@ -674,18 +895,24 @@ export class Markdown {
                 for (let i = 0; i < quoteTokens.length; i++) {
                     const quoteToken = quoteTokens[i];
                     const nextQuoteToken = quoteTokens[i + 1];
-                    renderedQuoteLines.push(...this.renderToken(quoteToken, quoteContentWidth, nextQuoteToken?.type, quoteInlineStyleContext));
+                    const childLines = this.renderToken(quoteToken, quoteContentWidth, nextQuoteToken?.type, quoteInlineStyleContext);
+                    const offset = renderedQuoteLines.length;
+                    renderedQuoteLines.push(...childLines);
+                    copyLineSources(childLines, renderedQuoteLines, offset);
                 }
                 // Avoid rendering an extra empty quote line before the outer blockquote spacing.
                 while (renderedQuoteLines.length > 0 && renderedQuoteLines[renderedQuoteLines.length - 1] === "") {
                     renderedQuoteLines.pop();
                 }
-                for (const quoteLine of renderedQuoteLines) {
+                for (let row = 0; row < renderedQuoteLines.length; row++) {
+                    const quoteLine = renderedQuoteLines[row];
                     const styledLine = applyQuoteStyle(quoteLine);
-                    const wrappedLines = wrapTextWithAnsi(styledLine, quoteContentWidth);
+                    const wrappedLines = this.wrapSource(styledLine, quoteContentWidth, getLineSources(renderedQuoteLines)?.[row]);
+                    const offset = lines.length;
                     for (const wrappedLine of wrappedLines) {
                         lines.push(this.theme.quoteBorder("│ ") + wrappedLine);
                     }
+                    copyLineSources(wrappedLines, lines, offset, 2);
                 }
                 if (nextTokenType && nextTokenType !== "space") {
                     lines.push(""); // Add spacing after blockquotes (unless space token follows)
@@ -694,6 +921,12 @@ export class Markdown {
             }
             case "hr":
                 lines.push(this.theme.hr("─".repeat(Math.min(width, 80))));
+                if (inlineRanges && source) {
+                    // Every rule glyph selects the authored rule, excluding block separators.
+                    const first = rangeAt(source.raw.ranges, 0);
+                    const last = rangeAt(source.raw.ranges, source.raw.text.trimEnd().length - 1);
+                    inlineRanges.push(repeatedRange(first && last ? { start: first.start, end: last.end } : null, stripTerminalSequences(lines[0]).length));
+                }
                 if (nextTokenType && nextTokenType !== "space") {
                     lines.push(""); // Add spacing after horizontal rules (unless space token follows)
                 }
@@ -714,20 +947,38 @@ export class Markdown {
                     lines.push(token.text);
                 }
         }
+        if (source && !getLineSources(lines)) {
+            const ranges = inlineRanges?.length
+                ? concatRanges(inlineRanges)
+                : source.text?.text === stripTerminalSequences(lines[0] ?? "")
+                    ? source.text.ranges
+                    : source.raw.text.trim() === stripTerminalSequences(lines[0] ?? "")
+                        ? sliceRanges(source.raw.ranges, source.raw.text.length - source.raw.text.trimStart().length, source.raw.text.trimEnd().length)
+                        : repeatedRange(null, stripTerminalSequences(lines[0] ?? "").length);
+            setLineSources(lines, lines.map((_, row) => ({ document: source.raw.document, ranges: row === 0 ? ranges : emptyRanges })));
+            this.enclose(token, ranges);
+        }
+        if (!source && this.activeSourceDocument) {
+            const document = this.activeSourceDocument;
+            setLineSources(lines, lines.map(() => ({ document, ranges: emptyRanges, unavailable: true })));
+        }
+        else if (token.type === "blockquote") {
+            this.enclose(token, concatRanges((getLineSources(lines) ?? []).map((line) => line?.ranges ?? emptyRanges)));
+        }
         return lines;
     }
     /**
      * Render inline `strong`/`em`/`del` through a theme hook. The hook is applied inside the surrounding style context,
      * so a color it sets wins over the heading or default text color instead of being overridden by it.
      */
-    renderEmphasisHook(tokens, styleContext, styleFn) {
+    renderEmphasisHook(tokens, styleContext, styleFn, ranges) {
         const innerStyleContext = {
             applyText: (text) => styleContext.applyText(styleFn(text)),
             stylePrefix: styleContext.stylePrefix + this.getStylePrefix(styleFn),
         };
-        return styleFn(this.renderInlineTokens(tokens, innerStyleContext)) + styleContext.stylePrefix;
+        return styleFn(this.renderInlineTokens(tokens, innerStyleContext, ranges)) + styleContext.stylePrefix;
     }
-    renderInlineTokens(tokens, styleContext) {
+    renderInlineTokens(tokens, styleContext, ranges) {
         let result = "";
         const resolvedStyleContext = styleContext ?? this.getDefaultInlineStyleContext();
         const { applyText, stylePrefix } = resolvedStyleContext;
@@ -736,6 +987,8 @@ export class Markdown {
             return segments.map((segment) => applyText(segment)).join("\n");
         };
         for (const token of tokens) {
+            const start = result.length;
+            const childRanges = ranges ? [] : undefined;
             switch (token.type) {
                 case "escape":
                     result += applyTextWithNewlines(this.options.preserveBackslashEscapes ? token.raw : token.text);
@@ -743,7 +996,7 @@ export class Markdown {
                 case "text":
                     // Text tokens in list items can have nested tokens for inline formatting
                     if (token.tokens && token.tokens.length > 0) {
-                        result += this.renderInlineTokens(token.tokens, resolvedStyleContext);
+                        result += this.renderInlineTokens(token.tokens, resolvedStyleContext, childRanges);
                     }
                     else {
                         result += applyTextWithNewlines(token.text);
@@ -751,23 +1004,23 @@ export class Markdown {
                     break;
                 case "paragraph":
                     // Paragraph tokens contain nested inline tokens
-                    result += this.renderInlineTokens(token.tokens || [], resolvedStyleContext);
+                    result += this.renderInlineTokens(token.tokens || [], resolvedStyleContext, childRanges);
                     break;
                 case "strong": {
                     if (this.theme.strong) {
-                        result += this.renderEmphasisHook(token.tokens || [], resolvedStyleContext, this.theme.strong);
+                        result += this.renderEmphasisHook(token.tokens || [], resolvedStyleContext, this.theme.strong, childRanges);
                         break;
                     }
-                    const boldContent = this.renderInlineTokens(token.tokens || [], resolvedStyleContext);
+                    const boldContent = this.renderInlineTokens(token.tokens || [], resolvedStyleContext, childRanges);
                     result += this.theme.bold(boldContent) + stylePrefix;
                     break;
                 }
                 case "em": {
                     if (this.theme.emphasis) {
-                        result += this.renderEmphasisHook(token.tokens || [], resolvedStyleContext, this.theme.emphasis);
+                        result += this.renderEmphasisHook(token.tokens || [], resolvedStyleContext, this.theme.emphasis, childRanges);
                         break;
                     }
-                    const italicContent = this.renderInlineTokens(token.tokens || [], resolvedStyleContext);
+                    const italicContent = this.renderInlineTokens(token.tokens || [], resolvedStyleContext, childRanges);
                     result += this.theme.italic(italicContent) + stylePrefix;
                     break;
                 }
@@ -785,7 +1038,7 @@ export class Markdown {
                     }
                     break;
                 case "link": {
-                    const linkText = this.renderInlineTokens(token.tokens || [], resolvedStyleContext);
+                    const linkText = this.renderInlineTokens(token.tokens || [], resolvedStyleContext, token.autolink ? undefined : childRanges);
                     const styledLink = this.theme.link(this.theme.underline(linkText));
                     if (getCapabilities().hyperlinks) {
                         // OSC 8: render as a clickable hyperlink. The URL is not printed inline,
@@ -812,10 +1065,10 @@ export class Markdown {
                     break;
                 case "del": {
                     if (this.theme.deleted) {
-                        result += this.renderEmphasisHook(token.tokens || [], resolvedStyleContext, this.theme.deleted);
+                        result += this.renderEmphasisHook(token.tokens || [], resolvedStyleContext, this.theme.deleted, childRanges);
                         break;
                     }
-                    const delContent = this.renderInlineTokens(token.tokens || [], resolvedStyleContext);
+                    const delContent = this.renderInlineTokens(token.tokens || [], resolvedStyleContext, childRanges);
                     result += this.theme.strikethrough(delContent) + stylePrefix;
                     break;
                 }
@@ -831,6 +1084,51 @@ export class Markdown {
                         result += applyTextWithNewlines(token.text);
                     }
             }
+            if (!ranges)
+                continue;
+            const rendered = stripTerminalSequences(result.slice(start));
+            const source = tokenSource(token);
+            let mapped = childRanges?.length
+                ? concatRanges(childRanges)
+                : source?.text?.text === rendered
+                    ? source.text.ranges
+                    : source?.raw.text === rendered
+                        ? source.raw.ranges
+                        : repeatedRange(null, rendered.length);
+            if (token.type === "latex_inline" && isLatexToken(token)) {
+                mapped = formulaRanges(token, rendered);
+            }
+            else if (token.type === "link" && token.autolink && source?.text && rendered.startsWith(source.text.text)) {
+                // Marked's synthetic label has no child lexer location. A visible
+                // suffix such as " (http://www.example.com)" is presentation only.
+                mapped = concatRanges([
+                    source.text.ranges,
+                    repeatedRange(undefined, rendered.length - source.text.ranges.length),
+                ]);
+            }
+            else if (token.type === "link" && mapped.length < rendered.length && source?.href) {
+                mapped = concatRanges([
+                    mapped,
+                    repeatedRange(undefined, 2),
+                    source.href.ranges,
+                    repeatedRange(undefined, 1),
+                ]);
+            }
+            else if (token.type === "link" && mapped.length < rendered.length && source) {
+                // A reference destination lives elsewhere; its visible suffix selects
+                // only this link's source, never the remote definition or intervening prose.
+                const first = rangeAt(source.raw.ranges, 0);
+                const last = rangeAt(source.raw.ranges, source.raw.ranges.length - 1);
+                mapped = concatRanges([
+                    mapped,
+                    repeatedRange(first && last ? { start: first.start, end: last.end } : null, rendered.length - mapped.length),
+                ]);
+            }
+            if (mapped.length < rendered.length) {
+                mapped = concatRanges([mapped, repeatedRange(null, rendered.length - mapped.length)]);
+            }
+            ranges.push(mapped);
+            this.enclose(token, token.type === "link" ? (source?.text?.ranges ?? mapped) : mapped);
         }
         while (stylePrefix && result.endsWith(stylePrefix)) {
             result = result.slice(0, -stylePrefix.length);
@@ -871,26 +1169,68 @@ export class Markdown {
             let renderedAnyLine = false;
             for (const itemToken of item.tokens) {
                 if (itemToken.type === "list") {
-                    lines.push(...this.renderList(itemToken, depth + 1, width, styleContext));
+                    const childLines = this.renderList(itemToken, depth + 1, width, styleContext);
+                    const offset = lines.length;
+                    lines.push(...childLines);
+                    copyLineSources(childLines, lines, offset);
                     renderedAnyLine = true;
                     continue;
                 }
                 const itemLines = this.renderToken(itemToken, itemWidth, undefined, styleContext);
-                for (const line of itemLines) {
-                    for (const wrappedLine of wrapTextWithAnsi(line, itemWidth)) {
+                for (let row = 0; row < itemLines.length; row++) {
+                    const line = itemLines[row];
+                    const fragments = this.wrapSource(line, itemWidth, getLineSources(itemLines)?.[row]);
+                    for (let part = 0; part < fragments.length; part++) {
+                        const wrappedLine = fragments[part];
                         const linePrefix = renderedAnyLine ? continuationPrefix : firstPrefix;
                         lines.push(linePrefix + wrappedLine);
+                        const source = getLineSources(fragments)?.[part];
+                        if (source) {
+                            let markerRange;
+                            if (!renderedAnyLine) {
+                                const raw = tokenSource(item)?.raw;
+                                const prefix = /^(?: {0,3})(?:[-+*]|\d{1,9}[.)])(?:[ \t]+|$)(?:\[[ xX]\][ \t]+)?/.exec(raw?.text ?? "");
+                                if (raw && prefix?.[0].length) {
+                                    const start = rangeAt(raw.ranges, 0)?.start;
+                                    const end = rangeAt(raw.ranges, prefix[0].length - 1)?.end;
+                                    if (start !== undefined && end !== undefined)
+                                        markerRange = { start, end };
+                                }
+                            }
+                            setLineSource(lines, lines.length - 1, {
+                                ...source,
+                                ranges: concatRanges([
+                                    repeatedRange(undefined, indent.length),
+                                    repeatedRange(markerRange, visibleWidth(linePrefix) - indent.length),
+                                    source.ranges,
+                                ]),
+                            });
+                        }
                         renderedAnyLine = true;
                     }
                 }
             }
             if (!renderedAnyLine) {
                 lines.push(firstPrefix);
+                const raw = tokenSource(item)?.raw;
+                const start = raw && rangeAt(raw.ranges, 0)?.start;
+                const end = raw && rangeAt(raw.ranges, raw.ranges.length - 1)?.end;
+                if (raw && start !== undefined && end !== undefined) {
+                    setLineSource(lines, lines.length - 1, {
+                        document: raw.document,
+                        ranges: repeatedRange({ start, end }, visibleWidth(firstPrefix)),
+                    });
+                }
             }
             if (token.loose && !isLastItem) {
                 lines.push("");
             }
         }
+        const document = tokenSource(token)?.raw.document;
+        if (document) {
+            const mapping = getLineSources(lines);
+            setLineSources(lines, lines.map((_, row) => mapping?.[row] ?? { document, ranges: emptyRanges }));
+        }
         return lines;
     }
     /**
@@ -913,13 +1253,13 @@ export class Markdown {
      * Delegates to wrapTextWithAnsi() so ANSI codes + long tokens are handled
      * consistently with the rest of the renderer.
      */
-    wrapCellText(text, maxWidth, stylePrefix = "") {
-        const lines = wrapTextWithAnsi(text, Math.max(1, maxWidth));
-        return lines.map((line, index) => {
+    wrapCellText(text, maxWidth, stylePrefix = "", source) {
+        const lines = this.wrapSource(text, Math.max(1, maxWidth), source);
+        return copyLineSources(lines, lines.map((line, index) => {
             // Reset text styles after each non-final fragment, then restore the surrounding style before padding and borders.
             const styleReset = index < lines.length - 1 ? "\x1b[22;23;24;25;27;28;29;39m" : "";
             return `${line}${styleReset}${stylePrefix}`;
-        });
+        }));
     }
     /**
      * Render a table with width-aware cell wrapping.
@@ -927,6 +1267,7 @@ export class Markdown {
      */
     renderTable(token, availableWidth, nextTokenType, styleContext) {
         const lines = [];
+        const source = tokenSource(token)?.raw;
         const numCols = token.header.length;
         if (numCols === 0) {
             return lines;
@@ -937,7 +1278,9 @@ export class Markdown {
         const availableForCells = availableWidth - borderOverhead;
         if (availableForCells < numCols) {
             // Too narrow to render a stable table. Fall back to raw markdown.
-            const fallbackLines = token.raw ? wrapTextWithAnsi(token.raw, availableWidth) : [];
+            const fallbackLines = token.raw
+                ? this.wrapSource(token.raw, availableWidth, source && { document: source.document, ranges: sliceRanges(source.ranges, 0, token.raw.length) })
+                : [];
             if (nextTokenType && nextTokenType !== "space") {
                 fallbackLines.push("");
             }
@@ -1026,8 +1369,9 @@ export class Markdown {
         lines.push(`┌─${topBorderCells.join("─┬─")}─┐`);
         // Render header with wrapping
         const headerCellLines = token.header.map((cell, i) => {
-            const text = this.renderInlineTokens(cell.tokens || [], styleContext);
-            return this.wrapCellText(text, columnWidths[i], styleContext?.stylePrefix);
+            const ranges = this.collectSources ? [] : undefined;
+            const text = this.renderInlineTokens(cell.tokens || [], styleContext, ranges);
+            return this.wrapCellText(text, columnWidths[i], styleContext?.stylePrefix, source && { document: source.document, ranges: concatRanges(ranges ?? []) });
         });
         const headerLineCount = Math.max(...headerCellLines.map((c) => c.length));
         for (let lineIdx = 0; lineIdx < headerLineCount; lineIdx++) {
@@ -1037,6 +1381,8 @@ export class Markdown {
                 return this.theme.bold(padded);
             });
             lines.push(`│ ${rowParts.join(" │ ")} │`);
+            if (source)
+                this.mapTableRow(lines, headerCellLines, lineIdx, columnWidths, source.document);
         }
         // Render separator
         const separatorCells = columnWidths.map((w) => "─".repeat(w));
@@ -1046,8 +1392,9 @@ export class Markdown {
         for (let rowIndex = 0; rowIndex < token.rows.length; rowIndex++) {
             const row = token.rows[rowIndex];
             const rowCellLines = row.map((cell, i) => {
-                const text = this.renderInlineTokens(cell.tokens || [], styleContext);
-                return this.wrapCellText(text, columnWidths[i], styleContext?.stylePrefix);
+                const ranges = this.collectSources ? [] : undefined;
+                const text = this.renderInlineTokens(cell.tokens || [], styleContext, ranges);
+                return this.wrapCellText(text, columnWidths[i], styleContext?.stylePrefix, source && { document: source.document, ranges: concatRanges(ranges ?? []) });
             });
             const rowLineCount = Math.max(...rowCellLines.map((c) => c.length));
             for (let lineIdx = 0; lineIdx < rowLineCount; lineIdx++) {
@@ -1056,6 +1403,8 @@ export class Markdown {
                     return text + " ".repeat(Math.max(0, columnWidths[colIdx] - visibleWidth(text)));
                 });
                 lines.push(`│ ${rowParts.join(" │ ")} │`);
+                if (source)
+                    this.mapTableRow(lines, rowCellLines, lineIdx, columnWidths, source.document);
             }
             if (rowIndex < token.rows.length - 1) {
                 lines.push(separatorLine);
@@ -1067,7 +1416,22 @@ export class Markdown {
         if (nextTokenType && nextTokenType !== "space") {
             lines.push(""); // Add spacing after table
         }
+        if (source) {
+            const mapping = getLineSources(lines);
+            setLineSources(lines, lines.map((_, row) => mapping?.[row] ?? { document: source.document, ranges: emptyRanges }));
+            this.enclose(token, concatRanges((getLineSources(lines) ?? []).map((line) => line?.ranges ?? emptyRanges)));
+        }
         return lines;
     }
+    mapTableRow(lines, cells, row, widths, document) {
+        const ranges = [repeatedRange(undefined, 2)];
+        for (let col = 0; col < cells.length; col++) {
+            const text = cells[col][row] ?? "";
+            const cell = getLineSources(cells[col])?.[row];
+            ranges.push(cell?.ranges ?? emptyRanges);
+            ranges.push(repeatedRange(undefined, Math.max(0, widths[col] - visibleWidth(text)) + 3));
+        }
+        setLineSource(lines, lines.length - 1, { document, ranges: concatRanges(ranges) });
+    }
 }
 //# sourceMappingURL=markdown.js.map