@aria-cli/cli 1.0.56 → 1.0.58

package/dist/ui/markdown/index.js

@@ -1,1460 +0,0 @@
-// packages/cli/src/ui/markdown/index.ts
-import chalk, { Chalk } from "chalk";
-import colorName from "color-name";
-import katex from "katex";
-import { Marked } from "marked";
-// @ts-expect-error marked-terminal has no type declarations
-import { markedTerminal } from "marked-terminal";
-import { highlightCode } from "./highlight.js";
-import { getTheme } from "../theme/index.js";
-const LIST_BULLETS = ["•", "◦", "▪", "▫"];
-/**
- * Render markdown string to terminal-formatted string
- */
-export function applyMarkdown(markdown, options = {}) {
-    const normalizedMarkdown = normalizeSectionNumbering(markdown);
-    const layoutStableMarkdown = options.mode === "streaming" ? demoteStreamingTables(normalizedMarkdown) : normalizedMarkdown;
-    const { content: protectedMarkdown, placeholders } = protectMathSpans(layoutStableMarkdown);
-    const colorWordMode = resolveColorWordMode(options.colorWordMode);
-    const localMarked = new Marked();
-    localMarked.use(markedTerminal({
-        showSectionPrefix: false,
-        reflowText: false,
-        emoji: false,
-        unescape: true,
-        width: options.width ?? (process.stdout.columns || 80),
-        tab: 2,
-        // Horizontal rule — use our dim dash style
-        hr: () => chalk.dim("─".repeat(options.width ?? 40)),
-    }));
-    // Override renderers for marked v17 compatibility and custom formatting
-    localMarked.use({
-        renderer: {
-            // Fix: marked-terminal text() drops inline token children in marked v17.
-            // Also apply color-word colorization here on raw text (before ANSI wrapping).
-            text(token) {
-                if ("tokens" in token && token.tokens) {
-                    return this.parser.parseInline(token.tokens);
-                }
-                return colorizeColorWords(token.text, colorWordMode);
-            },
-            // Paragraph — pass through without ANSI reset wrapping
-            // (marked-terminal's default wraps with chalk.reset which adds \x1b[0m)
-            paragraph(token) {
-                return this.parser.parseInline(token.tokens) + "\n\n";
-            },
-            // Code blocks — use our syntax highlighter
-            code(token) {
-                const theme = getTheme();
-                const language = token.lang || "text";
-                try {
-                    return "\n" + highlightCode(token.text, language) + "\n\n";
-                }
-                catch {
-                    return "\n" + chalk.hex(theme.colors.info)(token.text) + "\n\n";
-                }
-            },
-            // Inline code — use our theme color
-            codespan(token) {
-                const theme = getTheme();
-                return chalk.hex(theme.colors.info)(token.text);
-            },
-            // Links — OSC 8 hyperlinks
-            link(token) {
-                const theme = getTheme();
-                const text = this.parser.parseInline(token.tokens);
-                const href = token.href;
-                if (supportsHyperlinks()) {
-                    return `\x1b]8;;${href}\x07${chalk.hex(theme.colors.info).underline(text)}\x1b]8;;\x07`;
-                }
-                if (text === href) {
-                    return chalk.hex(theme.colors.info).underline(text);
-                }
-                return `${chalk.hex(theme.colors.info).underline(text)} (${chalk.dim(href)})`;
-            },
-            // Lists — custom bullets (•/◦/▪/▫) + ordered list start number preservation
-            list(token) {
-                const items = token.items;
-                const ordered = token.ordered;
-                const start = typeof token.start === "number" ? token.start : 1;
-                const depth = this._listDepth ?? 0;
-                const renderedItems = items.map((item, index) => {
-                    const bullet = ordered ? `${start + index}.` : LIST_BULLETS[depth % LIST_BULLETS.length];
-                    const indent = "  ".repeat(depth);
-                    const prevDepth = this._listDepth;
-                    this._listDepth = depth + 1;
-                    // parser.parse handles checkbox tokens automatically
-                    const content = this.parser.parse(item.tokens).trim();
-                    this._listDepth = prevDepth;
-                    return `${indent}${bullet} ${content}`;
-                });
-                return "\n" + renderedItems.join("\n") + "\n\n";
-            },
-            // Blockquotes — │ prefix with dim italic styling
-            blockquote(token) {
-                const content = this.parser.parse(token.tokens);
-                const lines = content.split("\n").filter((line) => line.trim());
-                return lines.map((line) => chalk.dim.italic(`│ ${line}`)).join("\n") + "\n\n";
-            },
-            // Table — width-aware rendering, wraps cells to fit terminal
-            table(token) {
-                const termWidth = options.width ?? (process.stdout.columns || 80);
-                const numCols = token.header.length;
-                if (numCols === 0)
-                    return "\n";
-                const headerTexts = token.header.map((cell) => this.parser.parseInline(cell.tokens));
-                const bodyTexts = token.rows.map((row) => row.map((cell) => this.parser.parseInline(cell.tokens)));
-                const colWidths = new Array(numCols).fill(0);
-                const minColWidths = new Array(numCols).fill(0);
-                for (let c = 0; c < numCols; c++) {
-                    const columnTexts = [headerTexts[c] ?? "", ...bodyTexts.map((row) => row[c] ?? "")];
-                    colWidths[c] = ansiStrippedLength(headerTexts[c] ?? "");
-                    for (const text of columnTexts) {
-                        colWidths[c] = Math.max(colWidths[c], ansiStrippedLength(text));
-                    }
-                    minColWidths[c] = getPreferredTableColumnWidth(columnTexts);
-                }
-                // overhead = │ borders (numCols+1) + 1 space padding each side (numCols*2)
-                const overhead = numCols + 1 + numCols * 2;
-                if (colWidths.reduce((a, b) => a + b, 0) + overhead > termWidth) {
-                    fitColumnsToWidth(colWidths, termWidth - overhead, minColWidths);
-                }
-                const hline = (l, m, r) => l + colWidths.map((w) => "─".repeat(w + 2)).join(m) + r;
-                const out = [hline("┌", "┬", "┐")];
-                out.push(...formatTableRow(headerTexts, colWidths, token.align));
-                out.push(hline("├", "┼", "┤"));
-                for (let r = 0; r < bodyTexts.length; r++) {
-                    out.push(...formatTableRow(bodyTexts[r], colWidths, token.align));
-                    if (r < bodyTexts.length - 1)
-                        out.push(hline("├", "┼", "┤"));
-                }
-                out.push(hline("└", "┴", "┘"));
-                return out.join("\n") + "\n\n";
-            },
-        },
-    });
-    const rendered = localMarked.parse(protectedMarkdown);
-    const restored = restoreMathSpans(rendered, placeholders, resolveMathRenderer(options.mathRenderer), colorWordMode);
-    return restored.replace(/\n{3,}/g, "\n\n").trimEnd();
-}
-function supportsHyperlinks() {
-    const term = process.env.TERM_PROGRAM ?? "";
-    const supported = ["iTerm.app", "WezTerm", "Hyper", "vscode"];
-    return supported.some((t) => term.includes(t));
-}
-function protectMathSpans(markdown) {
-    const placeholders = [];
-    let content = "";
-    let i = 0;
-    while (i < markdown.length) {
-        const fencedCode = readFencedCodeBlock(markdown, i);
-        if (fencedCode) {
-            content += fencedCode.segment;
-            i = fencedCode.end;
-            continue;
-        }
-        const inlineCode = readInlineCodeSpan(markdown, i);
-        if (inlineCode) {
-            content += inlineCode.segment;
-            i = inlineCode.end;
-            continue;
-        }
-        const mathSpan = readMathSpan(markdown, i);
-        if (mathSpan) {
-            const marker = `ARIAMATHTOKEN${placeholders.length}X`;
-            placeholders.push({ marker, original: mathSpan.segment, kind: mathSpan.kind });
-            content += marker;
-            i = mathSpan.end;
-            continue;
-        }
-        const bareMath = readBareLatexExpression(markdown, i);
-        if (bareMath) {
-            const marker = `ARIAMATHTOKEN${placeholders.length}X`;
-            placeholders.push({ marker, original: bareMath.segment, kind: "bare_math" });
-            content += marker;
-            i = bareMath.end;
-            continue;
-        }
-        const latexCommand = readLatexCommand(markdown, i);
-        if (latexCommand) {
-            const marker = `ARIAMATHTOKEN${placeholders.length}X`;
-            placeholders.push({ marker, original: latexCommand.segment, kind: "latex_command" });
-            content += marker;
-            i = latexCommand.end;
-            continue;
-        }
-        content += markdown[i];
-        i += 1;
-    }
-    return { content, placeholders };
-}
-function resolveMathRenderer(preferred) {
-    if (preferred)
-        return preferred;
-    const env = (process.env.ARIA_MARKDOWN_MATH_RENDERER ?? "").trim().toLowerCase();
-    if (env === "katex" || env === "fast")
-        return env;
-    return "fast";
-}
-function resolveColorWordMode(preferred) {
-    if (preferred)
-        return preferred;
-    const env = (process.env.ARIA_MARKDOWN_COLOR_WORD_MODE ?? "").trim().toLowerCase();
-    if (env === "always" || env === "never" || env === "auto") {
-        return env;
-    }
-    return "auto";
-}
-function restoreMathSpans(rendered, placeholders, mathRenderer, colorWordMode) {
-    const theme = getTheme();
-    let restored = rendered;
-    for (const placeholder of placeholders) {
-        const math = renderMathPlaceholder(placeholder, mathRenderer);
-        let replacement = math.style ? chalk.hex(theme.colors.info)(math.text) : math.text;
-        replacement = colorizeColorWords(replacement, colorWordMode);
-        restored = restored.split(placeholder.marker).join(replacement);
-    }
-    return restored;
-}
-function readMathSpan(text, start) {
-    if (text[start] !== "$" || isEscaped(text, start))
-        return null;
-    // Display math: $$...$$ (may span multiple lines)
-    if (text[start + 1] === "$" && !isEscaped(text, start + 1)) {
-        const close = findUnescaped(text, "$$", start + 2);
-        if (close === -1)
-            return null;
-        const inner = text.slice(start + 2, close);
-        if (!inner.trim())
-            return null;
-        return { segment: text.slice(start, close + 2), end: close + 2, kind: "display_math" };
-    }
-    // Inline math: $...$ (must close on the same line)
-    const close = findInlineMathClose(text, start + 1);
-    if (close === -1)
-        return null;
-    const inner = text.slice(start + 1, close);
-    if (!looksLikeInlineMath(inner))
-        return null;
-    return { segment: text.slice(start, close + 1), end: close + 1, kind: "inline_math" };
-}
-function findInlineMathClose(text, from) {
-    for (let i = from; i < text.length; i += 1) {
-        const ch = text[i];
-        if (ch === "\n")
-            return -1;
-        if (ch === "$" && !isEscaped(text, i))
-            return i;
-    }
-    return -1;
-}
-function findUnescaped(text, delimiter, from) {
-    let index = text.indexOf(delimiter, from);
-    while (index !== -1) {
-        if (!isEscaped(text, index))
-            return index;
-        index = text.indexOf(delimiter, index + delimiter.length);
-    }
-    return -1;
-}
-function isEscaped(text, index) {
-    let backslashCount = 0;
-    for (let i = index - 1; i >= 0 && text[i] === "\\"; i -= 1) {
-        backslashCount += 1;
-    }
-    return backslashCount % 2 === 1;
-}
-function looksLikeInlineMath(inner) {
-    const trimmed = inner.trim();
-    if (!trimmed)
-        return false;
-    if (/\\/.test(trimmed))
-        return true;
-    if (/[{}^_=<>+\-*/]/.test(trimmed))
-        return true;
-    return !/\s/.test(trimmed);
-}
-function readFencedCodeBlock(text, start) {
-    if (!isLineStart(text, start))
-        return null;
-    const rest = text.slice(start);
-    const match = rest.match(/^(```+|~~~+)[^\n]*\n/);
-    if (!match)
-        return null;
-    const fence = match[1];
-    let cursor = start + match[0].length;
-    while (cursor < text.length) {
-        const lineEnd = text.indexOf("\n", cursor);
-        const end = lineEnd === -1 ? text.length : lineEnd;
-        const line = text.slice(cursor, end).trim();
-        if (line.startsWith(fence)) {
-            const blockEnd = lineEnd === -1 ? text.length : lineEnd + 1;
-            return { segment: text.slice(start, blockEnd), end: blockEnd };
-        }
-        if (lineEnd === -1)
-            break;
-        cursor = lineEnd + 1;
-    }
-    // Unterminated fence: preserve the remainder verbatim.
-    return { segment: text.slice(start), end: text.length };
-}
-function readInlineCodeSpan(text, start) {
-    if (text[start] !== "`")
-        return null;
-    let ticks = 1;
-    while (text[start + ticks] === "`")
-        ticks += 1;
-    const delimiter = "`".repeat(ticks);
-    const close = text.indexOf(delimiter, start + ticks);
-    if (close === -1)
-        return null;
-    return { segment: text.slice(start, close + ticks), end: close + ticks };
-}
-function readLatexCommand(text, start) {
-    if (text[start] !== "\\")
-        return null;
-    const next = text[start + 1];
-    if (!next)
-        return null;
-    if (/[A-Za-z]/.test(next)) {
-        let end = start + 2;
-        while (end < text.length && /[A-Za-z]/.test(text[end])) {
-            end += 1;
-        }
-        return { segment: text.slice(start, end), end };
-    }
-    // Common TeX control-symbol commands used in model output.
-    if (/[,:;!{}%$#&_ ]/.test(next)) {
-        return { segment: text.slice(start, start + 2), end: start + 2 };
-    }
-    return null;
-}
-function readBareLatexExpression(text, start) {
-    if (text[start] !== "\\")
-        return null;
-    const first = readLatexCommand(text, start);
-    if (!first)
-        return null;
-    const firstName = first.segment.slice(1);
-    if (!isLikelyMathCommand(firstName))
-        return null;
-    let end = first.end;
-    while (end < text.length) {
-        const ch = text[end];
-        if (ch === "\n" || ch === "$")
-            break;
-        if (ch === "\\") {
-            const cmd = readLatexCommand(text, end);
-            if (!cmd)
-                break;
-            end = cmd.end;
-            continue;
-        }
-        if (/[A-Za-z0-9^_{}()[\]+\-*/=.,:; ]/.test(ch)) {
-            end += 1;
-            continue;
-        }
-        break;
-    }
-    const segment = text.slice(start, end).trimEnd();
-    if (segment.length <= first.segment.length)
-        return null;
-    return { segment, end: start + segment.length };
-}
-function isLikelyMathCommand(name) {
-    if (!name)
-        return false;
-    if (LATEX_SYMBOLS[name])
-        return true;
-    if (LATEX_FUNCTIONS.has(name))
-        return true;
-    return ["frac", "binom", "sqrt", "left", "right", "text"].includes(name);
-}
-const LATEX_SYMBOLS = {
-    alpha: "α",
-    beta: "β",
-    gamma: "γ",
-    delta: "δ",
-    epsilon: "ε",
-    varepsilon: "ε",
-    zeta: "ζ",
-    eta: "η",
-    theta: "θ",
-    vartheta: "ϑ",
-    iota: "ι",
-    kappa: "κ",
-    lambda: "λ",
-    mu: "μ",
-    nu: "ν",
-    xi: "ξ",
-    pi: "π",
-    varpi: "ϖ",
-    rho: "ρ",
-    varrho: "ϱ",
-    sigma: "σ",
-    varsigma: "ς",
-    tau: "τ",
-    upsilon: "υ",
-    phi: "ϕ",
-    varphi: "φ",
-    chi: "χ",
-    psi: "ψ",
-    omega: "ω",
-    Gamma: "Γ",
-    Delta: "Δ",
-    Theta: "Θ",
-    Lambda: "Λ",
-    Xi: "Ξ",
-    Pi: "Π",
-    Sigma: "Σ",
-    Upsilon: "Υ",
-    Phi: "Φ",
-    Psi: "Ψ",
-    Omega: "Ω",
-    int: "∫",
-    sum: "∑",
-    prod: "∏",
-    infty: "∞",
-    partial: "∂",
-    nabla: "∇",
-    times: "×",
-    cdot: "·",
-    pm: "±",
-    mp: "∓",
-    leq: "≤",
-    geq: "≥",
-    neq: "≠",
-    approx: "≈",
-    sim: "∼",
-    to: "→",
-    leftarrow: "←",
-    rightarrow: "→",
-    leftrightarrow: "↔",
-    mapsto: "↦",
-    in: "∈",
-    notin: "∉",
-    subset: "⊂",
-    subseteq: "⊆",
-    supset: "⊃",
-    supseteq: "⊇",
-    cup: "∪",
-    cap: "∩",
-    forall: "∀",
-    exists: "∃",
-    neg: "¬",
-    lnot: "¬",
-    land: "∧",
-    lor: "∨",
-};
-const LATEX_FUNCTIONS = new Set([
-    "sin",
-    "cos",
-    "tan",
-    "cot",
-    "sec",
-    "csc",
-    "log",
-    "ln",
-    "exp",
-    "max",
-    "min",
-    "lim",
-]);
-const SUPERSCRIPT_MAP = {
-    "0": "⁰",
-    "1": "¹",
-    "2": "²",
-    "3": "³",
-    "4": "⁴",
-    "5": "⁵",
-    "6": "⁶",
-    "7": "⁷",
-    "8": "⁸",
-    "9": "⁹",
-    "+": "⁺",
-    "-": "⁻",
-    "=": "⁼",
-    "(": "⁽",
-    ")": "⁾",
-    n: "ⁿ",
-    i: "ⁱ",
-    a: "ᵃ",
-    b: "ᵇ",
-    c: "ᶜ",
-    d: "ᵈ",
-    e: "ᵉ",
-    f: "ᶠ",
-    g: "ᵍ",
-    h: "ʰ",
-    j: "ʲ",
-    k: "ᵏ",
-    l: "ˡ",
-    m: "ᵐ",
-    o: "ᵒ",
-    p: "ᵖ",
-    r: "ʳ",
-    s: "ˢ",
-    t: "ᵗ",
-    u: "ᵘ",
-    v: "ᵛ",
-    w: "ʷ",
-    x: "ˣ",
-    y: "ʸ",
-    z: "ᶻ",
-};
-const SUBSCRIPT_MAP = {
-    "0": "₀",
-    "1": "₁",
-    "2": "₂",
-    "3": "₃",
-    "4": "₄",
-    "5": "₅",
-    "6": "₆",
-    "7": "₇",
-    "8": "₈",
-    "9": "₉",
-    "+": "₊",
-    "-": "₋",
-    "=": "₌",
-    "(": "₍",
-    ")": "₎",
-    a: "ₐ",
-    e: "ₑ",
-    h: "ₕ",
-    i: "ᵢ",
-    j: "ⱼ",
-    k: "ₖ",
-    l: "ₗ",
-    m: "ₘ",
-    n: "ₙ",
-    o: "ₒ",
-    p: "ₚ",
-    r: "ᵣ",
-    s: "ₛ",
-    t: "ₜ",
-    u: "ᵤ",
-    v: "ᵥ",
-    x: "ₓ",
-};
-function renderMathPlaceholder(placeholder, mathRenderer) {
-    if (mathRenderer === "katex") {
-        const displayMode = placeholder.kind === "display_math";
-        const source = placeholder.kind === "inline_math"
-            ? placeholder.original.slice(1, -1)
-            : placeholder.kind === "display_math"
-                ? placeholder.original.slice(2, -2)
-                : placeholder.original;
-        const rendered = renderWithKatexMath(source, displayMode);
-        if (rendered) {
-            return { text: rendered, style: true };
-        }
-    }
-    if (placeholder.kind === "inline_math") {
-        const inner = placeholder.original.slice(1, -1);
-        return { text: renderInlineMath(inner), style: true };
-    }
-    if (placeholder.kind === "display_math") {
-        const inner = placeholder.original.slice(2, -2);
-        return { text: renderDisplayMath(inner), style: true };
-    }
-    if (placeholder.kind === "bare_math") {
-        return { text: renderInlineMath(placeholder.original), style: true };
-    }
-    const bare = renderBareLatexCommand(placeholder.original);
-    const changed = bare !== placeholder.original;
-    return { text: bare, style: changed };
-}
-const KATEX_TERMINAL_CACHE = new Map();
-const MATHML_WRAPPER_TAGS = new Set(["math", "semantics", "mrow", "mstyle"]);
-const MATHML_ENTITY_MAP = {
-    amp: "&",
-    lt: "<",
-    gt: ">",
-    quot: '"',
-    apos: "'",
-    nbsp: " ",
-    ThinSpace: " ",
-    NegativeThinSpace: "",
-    MediumSpace: " ",
-    ApplyFunction: "",
-    InvisibleTimes: "·",
-    InvisibleComma: ",",
-};
-function renderWithKatexMath(latex, displayMode) {
-    const trimmed = latex.trim();
-    if (!trimmed)
-        return "";
-    const key = `${displayMode ? "display" : "inline"}:${trimmed}`;
-    const cached = KATEX_TERMINAL_CACHE.get(key);
-    if (cached !== undefined) {
-        return cached;
-    }
-    try {
-        const mathmlHtml = katex.renderToString(trimmed, {
-            displayMode,
-            throwOnError: false,
-            strict: "ignore",
-            output: "mathml",
-        });
-        const rendered = renderMathMlAsTerminalText(mathmlHtml, displayMode);
-        if (rendered != null && rendered.trim().length > 0) {
-            const value = rendered.trimEnd();
-            KATEX_TERMINAL_CACHE.set(key, value);
-            return value;
-        }
-    }
-    catch {
-        // Fall through to fast renderer.
-    }
-    return null;
-}
-function renderMathMlAsTerminalText(mathmlHtml, displayMode) {
-    const mathMatch = mathmlHtml.match(/<math[\s\S]*<\/math>/i);
-    if (!mathMatch)
-        return null;
-    const withoutAnnotation = mathMatch[0].replace(/<annotation[\s\S]*?<\/annotation>/gi, "");
-    const root = parseMathMl(withoutAnnotation);
-    if (!root)
-        return null;
-    if (displayMode) {
-        const top = unwrapMathMlNode(root);
-        if (top?.name === "mfrac") {
-            const children = childNodes(top);
-            const numerator = children[0] ? renderMathMlNode(children[0], false).trim() : "";
-            const denominator = children[1] ? renderMathMlNode(children[1], false).trim() : "";
-            return renderStackedFraction(numerator, denominator);
-        }
-    }
-    return renderMathMlNode(root, displayMode);
-}
-function parseMathMl(xml) {
-    const root = { name: "__root__", attrs: {}, children: [] };
-    const stack = [root];
-    const tokenRegex = /<!--[\s\S]*?-->|<[^>]+>|[^<]+/g;
-    let match;
-    while ((match = tokenRegex.exec(xml)) !== null) {
-        const token = match[0];
-        if (!token)
-            continue;
-        if (token.startsWith("<!--") || token.startsWith("<?")) {
-            continue;
-        }
-        if (token.startsWith("</")) {
-            if (stack.length > 1) {
-                stack.pop();
-            }
-            continue;
-        }
-        if (token.startsWith("<")) {
-            const selfClosing = token.endsWith("/>");
-            const inner = token.slice(1, token.length - (selfClosing ? 2 : 1)).trim();
-            if (!inner)
-                continue;
-            const nameMatch = inner.match(/^([^\s/>]+)/);
-            if (!nameMatch)
-                continue;
-            const rawName = nameMatch[1];
-            if (!rawName)
-                continue;
-            const name = rawName.replace(/^.*:/, "").toLowerCase();
-            const attrs = parseXmlAttributes(inner.slice(rawName.length));
-            const node = { name, attrs, children: [] };
-            const parent = stack[stack.length - 1];
-            if (parent) {
-                parent.children.push(node);
-            }
-            if (!selfClosing) {
-                stack.push(node);
-            }
-            continue;
-        }
-        const decoded = decodeMathMlEntities(token);
-        const normalized = normalizeMathMlText(decoded);
-        if (!normalized)
-            continue;
-        const parent = stack[stack.length - 1];
-        if (parent) {
-            parent.children.push(normalized);
-        }
-    }
-    const firstMath = childNodes(root).find((node) => node.name === "math");
-    return firstMath ?? null;
-}
-function parseXmlAttributes(source) {
-    const attrs = {};
-    const regex = /([A-Za-z_:][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
-    let match;
-    while ((match = regex.exec(source)) !== null) {
-        const rawName = match[1];
-        if (!rawName)
-            continue;
-        const value = match[3] ?? match[4] ?? "";
-        const name = rawName.replace(/^.*:/, "").toLowerCase();
-        attrs[name] = decodeMathMlEntities(value);
-    }
-    return attrs;
-}
-function decodeMathMlEntities(input) {
-    return input
-        .replace(/&#x([0-9a-fA-F]+);/g, (_m, hex) => {
-        const cp = Number.parseInt(hex, 16);
-        return Number.isFinite(cp) ? String.fromCodePoint(cp) : "";
-    })
-        .replace(/&#([0-9]+);/g, (_m, dec) => {
-        const cp = Number.parseInt(dec, 10);
-        return Number.isFinite(cp) ? String.fromCodePoint(cp) : "";
-    })
-        .replace(/&([A-Za-z][A-Za-z0-9]+);/g, (_m, name) => MATHML_ENTITY_MAP[name] ?? name);
-}
-function normalizeMathMlText(input) {
-    return input
-        .replace(/[\u200b\u2061\u2062\u2063\u2064]/g, "")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function unwrapMathMlNode(node) {
-    let current = node;
-    while (MATHML_WRAPPER_TAGS.has(current.name)) {
-        const nodes = childNodes(current);
-        if (nodes.length !== 1)
-            break;
-        current = nodes[0];
-    }
-    return current;
-}
-function childNodes(node) {
-    return node.children.filter((child) => typeof child !== "string");
-}
-function textChildren(node) {
-    let out = "";
-    for (const child of node.children) {
-        if (typeof child === "string") {
-            out += child;
-        }
-        else {
-            out += textChildren(child);
-        }
-    }
-    return normalizeMathMlText(out);
-}
-function renderMathMlNode(node, displayMode) {
-    switch (node.name) {
-        case "math":
-        case "semantics":
-        case "mrow":
-        case "mstyle":
-        case "mpadded":
-        case "mphantom":
-        case "none":
-            return joinMathMlChildren(node, displayMode);
-        case "mi":
-        case "mn":
-        case "mtext":
-            return textChildren(node);
-        case "mo": {
-            const op = textChildren(node);
-            return normalizeMathOperator(op);
-        }
-        case "mspace":
-            return " ";
-        case "mfrac": {
-            const nodes = childNodes(node);
-            const numerator = nodes[0] ? renderMathMlNode(nodes[0], false).trim() : "";
-            const denominator = nodes[1] ? renderMathMlNode(nodes[1], false).trim() : "";
-            return `${numerator}⁄${denominator}`.trim();
-        }
-        case "msup": {
-            const nodes = childNodes(node);
-            const base = nodes[0] ? renderMathMlNode(nodes[0], false) : "";
-            const exponent = nodes[1] ? renderMathMlNode(nodes[1], false) : "";
-            return `${base}${renderSuperscript(exponent)}`;
-        }
-        case "msub": {
-            const nodes = childNodes(node);
-            const base = nodes[0] ? renderMathMlNode(nodes[0], false) : "";
-            const sub = nodes[1] ? renderMathMlNode(nodes[1], false) : "";
-            return `${base}${renderSubscript(sub)}`;
-        }
-        case "msubsup": {
-            const nodes = childNodes(node);
-            const base = nodes[0] ? renderMathMlNode(nodes[0], false) : "";
-            const sub = nodes[1] ? renderMathMlNode(nodes[1], false) : "";
-            const sup = nodes[2] ? renderMathMlNode(nodes[2], false) : "";
-            return `${base}${renderSubscript(sub)}${renderSuperscript(sup)}`;
-        }
-        case "msqrt": {
-            const inner = joinMathMlChildren(node, false);
-            return inner ? `√(${inner})` : "√";
-        }
-        case "mroot": {
-            const nodes = childNodes(node);
-            const body = nodes[0] ? renderMathMlNode(nodes[0], false) : "";
-            const degree = nodes[1] ? renderMathMlNode(nodes[1], false) : "";
-            return degree ? `${degree}√(${body})` : `√(${body})`;
-        }
-        case "mfenced": {
-            const open = node.attrs.open ?? "(";
-            const close = node.attrs.close ?? ")";
-            const inner = joinMathMlChildren(node, false);
-            return `${open}${inner}${close}`;
-        }
-        case "mtable": {
-            const rows = childNodes(node).filter((child) => child.name === "mtr");
-            const renderedRows = rows
-                .map((row) => renderMathMlNode(row, displayMode).trim())
-                .filter((row) => row.length > 0);
-            if (renderedRows.length === 0)
-                return "";
-            if (displayMode) {
-                return renderedRows.join("\n");
-            }
-            return `[${renderedRows.join("; ")}]`;
-        }
-        case "mtr": {
-            const cols = childNodes(node)
-                .filter((child) => child.name === "mtd")
-                .map((cell) => renderMathMlNode(cell, displayMode).trim())
-                .filter((cell) => cell.length > 0);
-            return cols.join(" ");
-        }
-        case "mtd":
-            return joinMathMlChildren(node, displayMode);
-        case "annotation":
-            return "";
-        default:
-            return joinMathMlChildren(node, displayMode);
-    }
-}
-function joinMathMlChildren(node, displayMode) {
-    const parts = node.children.map((child) => {
-        if (typeof child === "string")
-            return child;
-        return renderMathMlNode(child, displayMode);
-    });
-    return normalizeMathSpacing(parts.join(""));
-}
-function normalizeMathOperator(input) {
-    if (!input)
-        return "";
-    if (input === "−")
-        return "-";
-    return input;
-}
-function normalizeMathSpacing(input) {
-    return input
-        .replace(/[\u200b\u2061\u2062\u2063\u2064]/g, "")
-        .replace(/([∫∑∏])([A-Za-z0-9α-ωΑ-Ω])/g, "$1 $2")
-        .replace(/([\u00B2\u00B3\u00B9\u2070-\u209F])([A-Za-zα-ωΑ-Ω])/g, "$1 $2")
-        .replace(/([)\]])([A-Za-zα-ωΑ-Ω])/g, "$1 $2")
-        .replace(/\s*([+\-−=≈≠≤≥<>×÷·∪∩])\s*/g, " $1 ")
-        .replace(/\s*,\s*/g, ", ")
-        .replace(/\s*;\s*/g, "; ")
-        .replace(/\s*:\s*/g, ": ")
-        .replace(/\(\s+/g, "(")
-        .replace(/\s+\)/g, ")")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function renderSuperscript(value) {
-    const compact = value.replace(/\s+/g, "");
-    if (!compact)
-        return "";
-    return convertScript(`{${compact}}`, SUPERSCRIPT_MAP, "^");
-}
-function renderSubscript(value) {
-    const compact = value.replace(/\s+/g, "");
-    if (!compact)
-        return "";
-    return convertScript(`{${compact}}`, SUBSCRIPT_MAP, "_");
-}
-function renderDisplayMath(latex) {
-    const trimmed = latex.trim();
-    if (!trimmed)
-        return "";
-    const wholeFraction = parseWholeBinaryCommand(trimmed, "frac");
-    if (wholeFraction) {
-        const numerator = renderInlineMath(wholeFraction.arg1).trim();
-        const denominator = renderInlineMath(wholeFraction.arg2).trim();
-        return renderStackedFraction(numerator, denominator);
-    }
-    return trimmed
-        .split("\n")
-        .map((line) => renderInlineMath(line))
-        .join("\n");
-}
-function renderInlineMath(latex) {
-    let rendered = latex.trim();
-    rendered = normalizeLatexWhitespace(rendered);
-    rendered = rendered.replace(/\\left\s*/g, "").replace(/\\right\s*/g, "");
-    rendered = replaceUnaryLatexCommand(rendered, "text", (arg) => renderInlineMath(arg));
-    rendered = replaceUnaryLatexCommand(rendered, "sqrt", (arg) => `√(${renderInlineMath(arg)})`);
-    rendered = replaceUnaryLatexCommand(rendered, "mathrm", (arg) => renderInlineMath(arg));
-    rendered = replaceUnaryLatexCommand(rendered, "mathbf", (arg) => renderInlineMath(arg));
-    rendered = replaceUnaryLatexCommand(rendered, "mathit", (arg) => renderInlineMath(arg));
-    rendered = replaceBinaryLatexCommand(rendered, "textcolor", (colorArg, textArg) => {
-        return applyLatexColor(colorArg, renderInlineMath(textArg));
-    });
-    rendered = replaceBinaryLatexCommand(rendered, "color", (colorArg, textArg) => {
-        return applyLatexColor(colorArg, renderInlineMath(textArg));
-    });
-    rendered = replaceBinaryLatexCommand(rendered, "colorbox", (colorArg, textArg) => {
-        return applyLatexBgColor(colorArg, renderInlineMath(textArg));
-    });
-    rendered = replaceBinaryLatexCommand(rendered, "frac", (num, den) => {
-        return `${renderInlineMath(num)}⁄${renderInlineMath(den)}`;
-    });
-    rendered = replaceBinaryLatexCommand(rendered, "binom", (top, bottom) => {
-        return `C(${renderInlineMath(top)}, ${renderInlineMath(bottom)})`;
-    });
-    rendered = replaceCommandWords(rendered);
-    rendered = replaceEscapedControlSymbols(rendered);
-    rendered = stripGroupingBraces(rendered);
-    rendered = applyScriptTransform(rendered);
-    rendered = rendered.replace(/\s{2,}/g, " ").trim();
-    return rendered;
-}
-function renderBareLatexCommand(command) {
-    if (!command.startsWith("\\"))
-        return command;
-    const name = command.slice(1);
-    if (command === "\\,")
-        return " ";
-    if (command === "\\;")
-        return " ";
-    if (command === "\\:")
-        return " ";
-    if (command === "\\!")
-        return "";
-    if (command === "\\ ")
-        return " ";
-    if (command === "\\{")
-        return "{";
-    if (command === "\\}")
-        return "}";
-    if (command === "\\%")
-        return "%";
-    if (command === "\\$")
-        return "$";
-    if (command === "\\#")
-        return "#";
-    if (command === "\\_")
-        return "_";
-    if (command === "\\&")
-        return "&";
-    if (LATEX_SYMBOLS[name])
-        return LATEX_SYMBOLS[name];
-    if (LATEX_FUNCTIONS.has(name))
-        return name;
-    return command;
-}
-function normalizeLatexWhitespace(input) {
-    return input
-        .replace(/\\,/g, " ")
-        .replace(/\\;/g, " ")
-        .replace(/\\:/g, " ")
-        .replace(/\\!/g, "")
-        .replace(/\\qquad/g, "    ")
-        .replace(/\\quad/g, "  ")
-        .replace(/~+/g, " ")
-        .replace(/\\ /g, " ");
-}
-function replaceCommandWords(input) {
-    let output = input;
-    const symbolNames = Object.keys(LATEX_SYMBOLS).sort((a, b) => b.length - a.length);
-    for (const name of symbolNames) {
-        const symbol = LATEX_SYMBOLS[name];
-        const regex = new RegExp(`\\\\${escapeRegExp(name)}\\b`, "g");
-        output = output.replace(regex, symbol);
-    }
-    for (const name of LATEX_FUNCTIONS) {
-        const regex = new RegExp(`\\\\${escapeRegExp(name)}\\b`, "g");
-        output = output.replace(regex, name);
-    }
-    return output;
-}
-function replaceEscapedControlSymbols(input) {
-    return input.replace(/\\([{}%$#&_])/g, "$1");
-}
-function stripGroupingBraces(input) {
-    const openMarker = "__ARIA_ESCAPED_LBRACE__";
-    const closeMarker = "__ARIA_ESCAPED_RBRACE__";
-    return input
-        .replace(/\\\{/g, openMarker)
-        .replace(/\\\}/g, closeMarker)
-        .replace(/[{}]/g, "")
-        .replaceAll(openMarker, "{")
-        .replaceAll(closeMarker, "}");
-}
-function applyScriptTransform(input) {
-    let output = input;
-    output = output.replace(/([A-Za-z0-9α-ωΑ-Ω)\]])\^(\{[^{}]*\}|.)/g, (_m, base, rawExp) => {
-        return `${base}${convertScript(rawExp, SUPERSCRIPT_MAP, "^")}`;
-    });
-    output = output.replace(/([A-Za-z0-9α-ωΑ-Ω)\]])_(\{[^{}]*\}|.)/g, (_m, base, rawSub) => {
-        return `${base}${convertScript(rawSub, SUBSCRIPT_MAP, "_")}`;
-    });
-    return output;
-}
-function convertScript(rawScript, table, fallbackPrefix) {
-    const content = unwrapScript(rawScript);
-    if (!content)
-        return "";
-    let out = "";
-    for (const ch of content) {
-        const mapped = table[ch];
-        if (!mapped) {
-            return `${fallbackPrefix}(${content})`;
-        }
-        out += mapped;
-    }
-    return out;
-}
-function unwrapScript(rawScript) {
-    if (rawScript.startsWith("{") && rawScript.endsWith("}")) {
-        return rawScript.slice(1, -1);
-    }
-    return rawScript;
-}
-function replaceUnaryLatexCommand(input, command, replacer) {
-    let output = "";
-    let i = 0;
-    const token = `\\${command}`;
-    while (i < input.length) {
-        if (startsWithCommand(input, token, i)) {
-            const arg = parseLatexGroup(input, i + token.length);
-            if (arg) {
-                output += replacer(arg.value);
-                i = arg.end;
-                continue;
-            }
-        }
-        output += input[i];
-        i += 1;
-    }
-    return output;
-}
-function replaceBinaryLatexCommand(input, command, replacer) {
-    let output = "";
-    let i = 0;
-    const token = `\\${command}`;
-    while (i < input.length) {
-        if (startsWithCommand(input, token, i)) {
-            const first = parseLatexGroup(input, i + token.length);
-            if (first) {
-                const second = parseLatexGroup(input, first.end);
-                if (second) {
-                    output += replacer(first.value, second.value);
-                    i = second.end;
-                    continue;
-                }
-            }
-        }
-        output += input[i];
-        i += 1;
-    }
-    return output;
-}
-function parseWholeBinaryCommand(input, command) {
-    const token = `\\${command}`;
-    const start = skipWhitespace(input, 0);
-    if (!startsWithCommand(input, token, start))
-        return null;
-    const first = parseLatexGroup(input, start + token.length);
-    if (!first)
-        return null;
-    const second = parseLatexGroup(input, first.end);
-    if (!second)
-        return null;
-    const end = skipWhitespace(input, second.end);
-    if (end !== input.length)
-        return null;
-    return { arg1: first.value, arg2: second.value };
-}
-function parseLatexGroup(input, start) {
-    let i = skipWhitespace(input, start);
-    if (i >= input.length)
-        return null;
-    if (input[i] === "{") {
-        const groupEnd = findMatchingBrace(input, i);
-        if (groupEnd === -1)
-            return null;
-        return { value: input.slice(i + 1, groupEnd), end: groupEnd + 1 };
-    }
-    if (input[i] === "\\") {
-        const cmd = readLatexCommand(input, i);
-        if (cmd) {
-            return { value: cmd.segment, end: cmd.end };
-        }
-    }
-    return { value: input[i], end: i + 1 };
-}
-function startsWithCommand(input, token, index) {
-    if (!input.startsWith(token, index))
-        return false;
-    const next = input[index + token.length];
-    return !next || !/[A-Za-z]/.test(next);
-}
-function skipWhitespace(input, start) {
-    let i = start;
-    while (i < input.length && /\s/.test(input[i])) {
-        i += 1;
-    }
-    return i;
-}
-function findMatchingBrace(input, openIndex) {
-    let depth = 0;
-    for (let i = openIndex; i < input.length; i += 1) {
-        const ch = input[i];
-        if (ch === "{" && !isEscaped(input, i))
-            depth += 1;
-        if (ch === "}" && !isEscaped(input, i)) {
-            depth -= 1;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-function renderStackedFraction(numerator, denominator) {
-    const width = Math.max(visibleWidth(numerator), visibleWidth(denominator), 1);
-    const bar = "─".repeat(width);
-    const top = centerText(numerator, width);
-    const bottom = centerText(denominator, width);
-    return `${top}\n${bar}\n${bottom}`;
-}
-function visibleWidth(value) {
-    return Array.from(value).length;
-}
-function centerText(value, width) {
-    const len = visibleWidth(value);
-    if (len >= width)
-        return value;
-    const left = Math.floor((width - len) / 2);
-    const right = width - len - left;
-    return `${" ".repeat(left)}${value}${" ".repeat(right)}`;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function buildColorWordRenderers(colorizer) {
-    const renderers = {};
-    const namedColors = colorName;
-    for (const [name, rgb] of Object.entries(namedColors)) {
-        const normalized = name.toLowerCase();
-        const [r, g, b] = rgb;
-        if (r === 0 && g === 0 && b === 0) {
-            // Pure black is unreadable on dark terminals; keep it visible.
-            renderers[normalized] = (word) => colorizer.blackBright(word);
-            continue;
-        }
-        renderers[normalized] = (word) => colorizer.rgb(r, g, b)(word);
-    }
-    // Defensive aliasing in case one spelling is absent in the source map.
-    if (renderers.gray && !renderers.grey) {
-        renderers.grey = renderers.gray;
-    }
-    if (renderers.grey && !renderers.gray) {
-        renderers.gray = renderers.grey;
-    }
-    return renderers;
-}
-const AUTO_COLOR_WORD_RENDERERS = buildColorWordRenderers(chalk);
-const FORCED_COLOR_WORD_RENDERERS = buildColorWordRenderers(new Chalk({ level: 3 }));
-const COLOR_WORD_NAMES = Object.keys(AUTO_COLOR_WORD_RENDERERS).sort((a, b) => b.length - a.length);
-const COLOR_WORD_REGEX = new RegExp(`\\b(${COLOR_WORD_NAMES.join("|")})\\b`, "gi");
-const FORCED_CHALK = new Chalk({ level: 3 });
-function applyLatexColor(colorSpec, text) {
-    const name = colorSpec.trim().toLowerCase();
-    const render = FORCED_COLOR_WORD_RENDERERS[name];
-    if (render)
-        return render(text);
-    return text;
-}
-function applyLatexBgColor(colorSpec, text) {
-    const name = colorSpec.trim().toLowerCase();
-    const namedColors = colorName;
-    const rgb = namedColors[name];
-    if (rgb) {
-        const [r, g, b] = rgb;
-        return FORCED_CHALK.bgRgb(r, g, b)(text);
-    }
-    return text;
-}
-function colorizeColorWords(text, mode = "auto") {
-    if (mode === "never")
-        return text;
-    const renderers = mode === "always" ? FORCED_COLOR_WORD_RENDERERS : AUTO_COLOR_WORD_RENDERERS;
-    return text.replace(COLOR_WORD_REGEX, (word) => {
-        const render = renderers[word.toLowerCase()];
-        return render ? render(word) : word;
-    });
-}
-function normalizeSectionNumbering(markdown) {
-    const lines = markdown.split("\n");
-    return lines
-        .map((line, index) => {
-        const match = line.match(/^(\d+)\.\s+(.+)$/);
-        if (!match)
-            return line;
-        const prevBlank = index === 0 || !lines[index - 1].trim();
-        const nextBlank = index === lines.length - 1 || !lines[index + 1].trim();
-        if (!prevBlank || !nextBlank)
-            return line;
-        // Section-style numbered headers (`N. Title` with blank lines around)
-        // should remain literal text, not markdown ordered-list items.
-        return `${match[1]}\\. ${match[2]}`;
-    })
-        .join("\n");
-}
-function isLineStart(text, index) {
-    return index === 0 || text[index - 1] === "\n";
-}
-function demoteStreamingTables(markdown) {
-    const lines = markdown.split("\n");
-    const output = [];
-    for (let i = 0; i < lines.length; i += 1) {
-        const current = lines[i] ?? "";
-        const next = lines[i + 1] ?? "";
-        if (looksLikeMarkdownTableHeader(current) && looksLikeMarkdownTableSeparator(next)) {
-            let cursor = i;
-            while (cursor < lines.length && looksLikeMarkdownTableRow(lines[cursor] ?? "")) {
-                output.push(escapeMarkdownTableRow(lines[cursor]));
-                cursor += 1;
-            }
-            i = cursor - 1;
-            continue;
-        }
-        output.push(current);
-    }
-    return output.join("\n");
-}
-function looksLikeMarkdownTableHeader(line) {
-    const trimmed = line.trim();
-    if (!trimmed.includes("|"))
-        return false;
-    if (/^[-:|\s]+$/.test(trimmed))
-        return false;
-    const cells = splitMarkdownTableCells(trimmed);
-    return cells.length >= 2 && cells.some((cell) => cell.length > 0);
-}
-function looksLikeMarkdownTableSeparator(line) {
-    const cells = splitMarkdownTableCells(line.trim());
-    return cells.length >= 2 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
-}
-function looksLikeMarkdownTableRow(line) {
-    const trimmed = line.trim();
-    return trimmed.length > 0 && trimmed.includes("|");
-}
-function splitMarkdownTableCells(line) {
-    let normalized = line.trim();
-    if (normalized.startsWith("|"))
-        normalized = normalized.slice(1);
-    if (normalized.endsWith("|"))
-        normalized = normalized.slice(0, -1);
-    return normalized.split("|").map((cell) => cell.trim());
-}
-function escapeMarkdownTableRow(line) {
-    return line.replace(/\|/g, "\\|");
-}
-// ── Table rendering helpers ──────────────────────────────────────────
-const ANSI_ESCAPE_RE = /\x1b\[[0-9;]*m|\x1b\]8;;[^\x07]*\x07/g;
-function stripAnsiCodes(text) {
-    return text.replace(ANSI_ESCAPE_RE, "");
-}
-function ansiStrippedLength(text) {
-    return stripAnsiCodes(text).length;
-}
-function fitColumnsToWidth(colWidths, available, minColWidths) {
-    const MIN_COL = 3;
-    const total = colWidths.reduce((a, b) => a + b, 0);
-    if (total <= available)
-        return;
-    const adjustedMinWidths = shrinkPreferredTableMinWidths(minColWidths, available, MIN_COL);
-    const target = available;
-    const ratio = target / total;
-    for (let i = 0; i < colWidths.length; i++) {
-        colWidths[i] = Math.max(adjustedMinWidths[i] ?? MIN_COL, Math.floor(colWidths[i] * ratio));
-    }
-    // Pass 1: trim widest columns down to their preferred minimums
-    let current = colWidths.reduce((a, b) => a + b, 0);
-    while (current > target) {
-        let widest = 0;
-        for (let i = 1; i < colWidths.length; i++) {
-            if (colWidths[i] > colWidths[widest])
-                widest = i;
-        }
-        if (colWidths[widest] <= (adjustedMinWidths[widest] ?? MIN_COL))
-            break;
-        colWidths[widest]--;
-        current--;
-    }
-    // Pass 2: if still over budget, force-shrink past preferred mins to absolute MIN_COL
-    while (current > target) {
-        let widest = 0;
-        for (let i = 1; i < colWidths.length; i++) {
-            if (colWidths[i] > colWidths[widest])
-                widest = i;
-        }
-        if (colWidths[widest] <= MIN_COL)
-            break;
-        colWidths[widest]--;
-        current--;
-    }
-}
-function shrinkPreferredTableMinWidths(preferredMinWidths, available, absoluteMinWidth) {
-    const adjusted = preferredMinWidths.map((width) => Math.max(width, absoluteMinWidth));
-    let total = adjusted.reduce((sum, width) => sum + width, 0);
-    while (total > available) {
-        let widest = -1;
-        for (let i = 0; i < adjusted.length; i++) {
-            if (adjusted[i] <= absoluteMinWidth)
-                continue;
-            if (widest === -1 || adjusted[i] > adjusted[widest]) {
-                widest = i;
-            }
-        }
-        if (widest === -1)
-            break;
-        adjusted[widest]--;
-        total--;
-    }
-    return adjusted;
-}
-function getPreferredTableColumnWidth(texts) {
-    const ABSOLUTE_MIN = 3;
-    const SOFT_MIN_CAP = 24;
-    let naturalWidth = ABSOLUTE_MIN;
-    let longestWord = ABSOLUTE_MIN;
-    for (const text of texts) {
-        const normalized = normalizeTableCellText(text);
-        naturalWidth = Math.max(naturalWidth, ansiStrippedLength(normalized));
-        longestWord = Math.max(longestWord, longestWordLength(normalized));
-    }
-    // Prefer word-boundary wrapping up to SOFT_MIN_CAP; longer words get hard-broken
-    return Math.min(Math.max(ABSOLUTE_MIN, longestWord), SOFT_MIN_CAP);
-}
-function longestWordLength(text) {
-    return stripAnsiCodes(text)
-        .split(/\s+/)
-        .reduce((max, word) => Math.max(max, word.length), 0);
-}
-function wrapCellText(text, width) {
-    const normalizedText = normalizeTableCellText(text);
-    if (width <= 0 || !normalizedText)
-        return [normalizedText || ""];
-    // Handle explicit line breaks (from <br> in markdown cells) first
-    if (normalizedText.includes("\n")) {
-        const result = [];
-        for (const segment of normalizedText.split("\n")) {
-            result.push(...wrapCellText(segment, width));
-        }
-        return result;
-    }
-    if (ansiStrippedLength(normalizedText) <= width)
-        return [normalizedText];
-    // Tokenize into ANSI escapes and visible segments
-    const segments = [];
-    let last = 0;
-    const re = new RegExp(ANSI_ESCAPE_RE.source, "g");
-    let m;
-    while ((m = re.exec(normalizedText)) !== null) {
-        if (m.index > last)
-            segments.push({ ansi: false, value: normalizedText.slice(last, m.index) });
-        segments.push({ ansi: true, value: m[0] });
-        last = re.lastIndex;
-    }
-    if (last < normalizedText.length) {
-        segments.push({ ansi: false, value: normalizedText.slice(last) });
-    }
-    // Word-wrap visible segments, preserving ANSI codes
-    const lines = [];
-    let line = "";
-    let lineW = 0;
-    const hardBreak = (word) => {
-        for (let i = 0; i < word.length; i += width) {
-            if (line && lineW > 0)
-                lines.push(line);
-            line = word.slice(i, i + width);
-            lineW = line.length;
-        }
-    };
-    for (const seg of segments) {
-        if (seg.ansi) {
-            line += seg.value;
-            continue;
-        }
-        const words = seg.value.split(/(\s+)/);
-        for (const word of words) {
-            if (!word)
-                continue;
-            const wLen = word.length;
-            const isWs = !word.trim();
-            if (isWs && lineW === 0)
-                continue; // skip leading whitespace on new lines
-            if (lineW + wLen <= width) {
-                line += word;
-                lineW += wLen;
-            }
-            else if (lineW === 0) {
-                hardBreak(word);
-            }
-            else if (isWs) {
-                lines.push(line);
-                line = "";
-                lineW = 0;
-            }
-            else {
-                // Word overflows current line — start new line, hard-break if still too wide
-                lines.push(line);
-                line = "";
-                lineW = 0;
-                if (wLen > width) {
-                    hardBreak(word);
-                }
-                else {
-                    line = word;
-                    lineW = wLen;
-                }
-            }
-        }
-    }
-    if (line || lines.length === 0)
-        lines.push(line);
-    return lines;
-}
-function normalizeTableCellText(text) {
-    return text
-        .replace(/\s*\n+\s*/g, " ")
-        .replace(/\(\s+/g, "(")
-        .replace(/\s+\)/g, ")")
-        .replace(/\[\s+/g, "[")
-        .replace(/\s+\]/g, "]")
-        .replace(/[ \t]{2,}/g, " ")
-        .trim();
-}
-function padCellText(text, width, align) {
-    const vis = ansiStrippedLength(text);
-    if (vis >= width)
-        return text;
-    const gap = width - vis;
-    if (align === "right")
-        return " ".repeat(gap) + text;
-    if (align === "center") {
-        const left = Math.floor(gap / 2);
-        return " ".repeat(left) + text + " ".repeat(gap - left);
-    }
-    return text + " ".repeat(gap);
-}
-function formatTableRow(cells, colWidths, align) {
-    const wrapped = cells.map((text, c) => wrapCellText(text, colWidths[c]));
-    const height = Math.max(...wrapped.map((w) => w.length), 1);
-    const result = [];
-    for (let ln = 0; ln < height; ln++) {
-        const parts = wrapped.map((cellLines, c) => padCellText(cellLines[ln] ?? "", colWidths[c], align[c] ?? null));
-        result.push("│ " + parts.join(" │ ") + " │");
-    }
-    return result;
-}
-export { tokenize } from "./tokenizer.js";
-export { highlightCode, isLanguageSupported } from "./highlight.js";
-//# sourceMappingURL=index.js.map