@wangzhizhi/remi 0.0.1-alpha

package/node_modules/@remi/terminal-markdown/dist/index.js

@@ -0,0 +1,1412 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+import hljs from 'highlight.js/lib/common';
+import { marked } from 'marked';
+export const defaultTerminalMarkdownTheme = {
+    text: '#d7d9dd',
+    muted: '#7d838b',
+    accent: '#59f3f3',
+    success: '#56d364',
+    danger: '#ff6b6b',
+    warning: '#f2cc60',
+    emphasis: '#f4b8e4',
+    strong: '#ffffff',
+    strongEmphasis: '#c7a4ff',
+    orderedListMarker: '#c7a4ff',
+    quoteText: '#7d838b',
+    diffAddBackground: '#123d28',
+    diffRemoveBackground: '#4a1e1e',
+    codeBackground: '#1f2226',
+    codeKeyword: '#c792ea',
+    codeString: '#a6e3a1',
+    codeNumber: '#f9e2af',
+    codeComment: '#7d838b',
+    codeType: '#89ddff',
+    codeTitle: '#82aaff',
+    codeFunction: '#7aa2f7',
+    codeVariable: '#f2cdcd',
+    codeProperty: '#94e2d5',
+    codeOperator: '#89ddff',
+    codeMeta: '#f38ba8',
+    codeSection: '#fab387',
+    codeRegexp: '#fab387',
+    codePunctuation: '#bac2de',
+};
+export const terminalSyntaxThemeIds = [
+    'default',
+    'catppuccin-frappe',
+    'catppuccin-latte',
+    'catppuccin-macchiato',
+    'catppuccin-mocha',
+    'base16-256',
+    'base16-eighties-dark',
+    'base16-mocha-dark',
+    'base16-ocean-dark',
+    'base16-ocean-light',
+];
+const terminalSyntaxThemeDefinitions = {
+    default: {
+        id: 'default',
+        label: 'Default',
+        description: 'Current Remi syntax palette.',
+        palette: {},
+    },
+    'catppuccin-frappe': {
+        id: 'catppuccin-frappe',
+        label: 'Catppuccin Frappe',
+        description: 'Soft dark blue-gray palette.',
+        palette: {
+            text: '#c6d0f5',
+            muted: '#838ba7',
+            emphasis: '#f4b8e4',
+            strong: '#ffffff',
+            strongEmphasis: '#ca9ee6',
+            orderedListMarker: '#ca9ee6',
+            quoteText: '#838ba7',
+            diffAddBackground: '#143d2b',
+            diffRemoveBackground: '#4b2028',
+            codeBackground: '#292c3c',
+            codeKeyword: '#ca9ee6',
+            codeString: '#a6d189',
+            codeNumber: '#ef9f76',
+            codeComment: '#838ba7',
+            codeType: '#8caaee',
+            codeTitle: '#8caaee',
+            codeFunction: '#8caaee',
+            codeVariable: '#c6d0f5',
+            codeProperty: '#81c8be',
+            codeOperator: '#99d1db',
+            codeMeta: '#e78284',
+            codeSection: '#eebebe',
+            codeRegexp: '#f2d5cf',
+            codePunctuation: '#b5bfe2',
+        },
+    },
+    'catppuccin-latte': {
+        id: 'catppuccin-latte',
+        label: 'Catppuccin Latte',
+        description: 'Light palette with warm comments.',
+        palette: {
+            text: '#4c4f69',
+            muted: '#8c8fa1',
+            emphasis: '#ea76cb',
+            strong: '#1e1e2e',
+            strongEmphasis: '#8839ef',
+            orderedListMarker: '#8839ef',
+            quoteText: '#8c8fa1',
+            diffAddBackground: '#d7f0d2',
+            diffRemoveBackground: '#f6d6d6',
+            codeBackground: '#eff1f5',
+            codeKeyword: '#8839ef',
+            codeString: '#40a02b',
+            codeNumber: '#fe640b',
+            codeComment: '#8c8fa1',
+            codeType: '#1e66f5',
+            codeTitle: '#1e66f5',
+            codeFunction: '#1e66f5',
+            codeVariable: '#4c4f69',
+            codeProperty: '#179299',
+            codeOperator: '#04a5e5',
+            codeMeta: '#d20f39',
+            codeSection: '#df8e1d',
+            codeRegexp: '#dd7878',
+            codePunctuation: '#6c6f85',
+        },
+    },
+    'catppuccin-macchiato': {
+        id: 'catppuccin-macchiato',
+        label: 'Catppuccin Macchiato',
+        description: 'Dark lavender-blue palette.',
+        palette: {
+            text: '#cad3f5',
+            muted: '#8087a2',
+            emphasis: '#f5bde6',
+            strong: '#ffffff',
+            strongEmphasis: '#c6a0f6',
+            orderedListMarker: '#c6a0f6',
+            quoteText: '#8087a2',
+            diffAddBackground: '#153e2e',
+            diffRemoveBackground: '#4f2028',
+            codeBackground: '#24273a',
+            codeKeyword: '#c6a0f6',
+            codeString: '#a6da95',
+            codeNumber: '#f5a97f',
+            codeComment: '#8087a2',
+            codeType: '#8aadf4',
+            codeTitle: '#8aadf4',
+            codeFunction: '#8aadf4',
+            codeVariable: '#cad3f5',
+            codeProperty: '#8bd5ca',
+            codeOperator: '#91d7e3',
+            codeMeta: '#ed8796',
+            codeSection: '#f0c6c6',
+            codeRegexp: '#f4dbd6',
+            codePunctuation: '#b8c0e0',
+        },
+    },
+    'catppuccin-mocha': {
+        id: 'catppuccin-mocha',
+        label: 'Catppuccin Mocha',
+        description: 'High-contrast dark pastel palette.',
+        palette: {
+            text: '#cdd6f4',
+            muted: '#7f849c',
+            emphasis: '#f5c2e7',
+            strong: '#ffffff',
+            strongEmphasis: '#cba6f7',
+            orderedListMarker: '#cba6f7',
+            quoteText: '#7f849c',
+            diffAddBackground: '#143c2c',
+            diffRemoveBackground: '#4a1f2a',
+            codeBackground: '#1e1e2e',
+            codeKeyword: '#cba6f7',
+            codeString: '#a6e3a1',
+            codeNumber: '#fab387',
+            codeComment: '#7f849c',
+            codeType: '#89b4fa',
+            codeTitle: '#89b4fa',
+            codeFunction: '#89b4fa',
+            codeVariable: '#cdd6f4',
+            codeProperty: '#94e2d5',
+            codeOperator: '#89dceb',
+            codeMeta: '#f38ba8',
+            codeSection: '#f2cdcd',
+            codeRegexp: '#f5e0dc',
+            codePunctuation: '#bac2de',
+        },
+    },
+    'base16-256': {
+        id: 'base16-256',
+        label: 'Base16 256',
+        description: 'ANSI-friendly dark palette.',
+        palette: {
+            text: '#e0e0e0',
+            muted: '#808080',
+            diffAddBackground: '#1f3a2b',
+            diffRemoveBackground: '#3a2020',
+            codeBackground: '#101010',
+            codeKeyword: '#af87ff',
+            codeString: '#afd75f',
+            codeNumber: '#ffaf5f',
+            codeComment: '#808080',
+            codeType: '#87afff',
+            codeTitle: '#87d7ff',
+            codeFunction: '#87d7ff',
+            codeVariable: '#e0e0e0',
+            codeProperty: '#87d7d7',
+            codeOperator: '#87d7ff',
+            codeMeta: '#ff5f87',
+            codeSection: '#ffd75f',
+            codeRegexp: '#ffaf5f',
+            codePunctuation: '#bcbcbc',
+        },
+    },
+    'base16-eighties-dark': {
+        id: 'base16-eighties-dark',
+        label: 'Base16 Eighties Dark',
+        description: 'Retro dark palette with warm strings.',
+        palette: {
+            text: '#d3d0c8',
+            muted: '#747369',
+            diffAddBackground: '#253827',
+            diffRemoveBackground: '#442526',
+            codeBackground: '#2d2d2d',
+            codeKeyword: '#cc99cc',
+            codeString: '#99cc99',
+            codeNumber: '#f99157',
+            codeComment: '#747369',
+            codeType: '#6699cc',
+            codeTitle: '#6699cc',
+            codeFunction: '#6699cc',
+            codeVariable: '#d3d0c8',
+            codeProperty: '#66cccc',
+            codeOperator: '#66cccc',
+            codeMeta: '#f2777a',
+            codeSection: '#ffcc66',
+            codeRegexp: '#f99157',
+            codePunctuation: '#d3d0c8',
+        },
+    },
+    'base16-mocha-dark': {
+        id: 'base16-mocha-dark',
+        label: 'Base16 Mocha Dark',
+        description: 'Muted coffee-toned dark palette.',
+        palette: {
+            text: '#d0c8c6',
+            muted: '#7e705a',
+            diffAddBackground: '#293a26',
+            diffRemoveBackground: '#472525',
+            codeBackground: '#211f1f',
+            codeKeyword: '#a89bb9',
+            codeString: '#beb55b',
+            codeNumber: '#b98b56',
+            codeComment: '#7e705a',
+            codeType: '#8ab3b5',
+            codeTitle: '#8ab3b5',
+            codeFunction: '#8ab3b5',
+            codeVariable: '#d0c8c6',
+            codeProperty: '#7bbda4',
+            codeOperator: '#7bbda4',
+            codeMeta: '#cb6077',
+            codeSection: '#f4bc87',
+            codeRegexp: '#b98b56',
+            codePunctuation: '#b8afad',
+        },
+    },
+    'base16-ocean-dark': {
+        id: 'base16-ocean-dark',
+        label: 'Base16 Ocean Dark',
+        description: 'Cool balanced dark palette.',
+        palette: {
+            text: '#c0c5ce',
+            muted: '#65737e',
+            diffAddBackground: '#243b31',
+            diffRemoveBackground: '#40262b',
+            codeBackground: '#2b303b',
+            codeKeyword: '#b48ead',
+            codeString: '#a3be8c',
+            codeNumber: '#d08770',
+            codeComment: '#65737e',
+            codeType: '#8fa1b3',
+            codeTitle: '#8fa1b3',
+            codeFunction: '#8fa1b3',
+            codeVariable: '#c0c5ce',
+            codeProperty: '#96b5b4',
+            codeOperator: '#96b5b4',
+            codeMeta: '#bf616a',
+            codeSection: '#ebcb8b',
+            codeRegexp: '#d08770',
+            codePunctuation: '#c0c5ce',
+        },
+    },
+    'base16-ocean-light': {
+        id: 'base16-ocean-light',
+        label: 'Base16 Ocean Light',
+        description: 'Light variant of the ocean palette.',
+        palette: {
+            text: '#4f5b66',
+            muted: '#a7adba',
+            diffAddBackground: '#dcebd7',
+            diffRemoveBackground: '#f1d7da',
+            codeBackground: '#eff1f5',
+            codeKeyword: '#b48ead',
+            codeString: '#90a959',
+            codeNumber: '#d08770',
+            codeComment: '#a7adba',
+            codeType: '#8fa1b3',
+            codeTitle: '#8fa1b3',
+            codeFunction: '#8fa1b3',
+            codeVariable: '#4f5b66',
+            codeProperty: '#5fb3b3',
+            codeOperator: '#5fb3b3',
+            codeMeta: '#bf616a',
+            codeSection: '#f7ca88',
+            codeRegexp: '#d08770',
+            codePunctuation: '#65737e',
+        },
+    },
+};
+export function listTerminalSyntaxThemes() {
+    return terminalSyntaxThemeIds.map(id => {
+        const { label, description } = terminalSyntaxThemeDefinitions[id];
+        return { id, label, description };
+    });
+}
+export function isTerminalSyntaxThemeId(value) {
+    return typeof value === 'string' && terminalSyntaxThemeIds.includes(value);
+}
+export function resolveTerminalSyntaxThemeId(value) {
+    return isTerminalSyntaxThemeId(value) ? value : 'default';
+}
+export function terminalSyntaxThemeLabel(id) {
+    const resolved = resolveTerminalSyntaxThemeId(id);
+    return terminalSyntaxThemeDefinitions[resolved].label;
+}
+export function applyTerminalSyntaxTheme(theme, id) {
+    const resolved = resolveTerminalSyntaxThemeId(id);
+    return { ...theme, ...terminalSyntaxThemeDefinitions[resolved].palette };
+}
+const markdownSyntaxPattern = /[`*_#[\]>|~-]|\d+[.)、]\s|```/;
+const maxHighlightJsLineLength = 500;
+const maxHighlightJsBlockLength = 120_000;
+const maxHighlightCacheEntries = 2000;
+const maxHighlightBlockCacheEntries = 500;
+const codeTabSize = 4;
+const codePanelPadding = '  ';
+const omissionMarker = '⋮';
+const highlightLineCache = new Map();
+const highlightBlockCache = new Map();
+export function TerminalMarkdown({ text, theme = defaultTerminalMarkdownTheme, width, paddingX = 0 }) {
+    const tokens = useMemo(() => parseMarkdownTokens(text), [text]);
+    const contentWidth = paddedContentWidth(width, paddingX);
+    return (_jsx(_Fragment, { children: tokens.map((token, index) => (_jsx(MarkdownBlockView, { token: token, theme: theme, width: width, contentWidth: contentWidth, paddingX: paddingX }, `${index}-${token.type}-${token.raw ?? token.text ?? ''}`))) }));
+}
+export function StreamingMarkdown({ text, theme = defaultTerminalMarkdownTheme, width, paddingX = 0 }) {
+    const { stable, tail } = useMemo(() => splitStableMarkdownPrefix(text), [text]);
+    const stableTokens = useMemo(() => parseMarkdownTokens(stable), [stable]);
+    const tailTokens = useMemo(() => parseMarkdownTokens(tail), [tail]);
+    const contentWidth = paddedContentWidth(width, paddingX);
+    return (_jsxs(_Fragment, { children: [stableTokens.map((token, index) => (_jsx(MarkdownBlockView, { token: token, theme: theme, width: width, contentWidth: contentWidth, paddingX: paddingX }, `stable-${index}-${token.type}-${token.raw ?? token.text ?? ''}`))), tailTokens.map((token, index) => (_jsx(MarkdownBlockView, { token: token, theme: theme, width: width, contentWidth: contentWidth, paddingX: paddingX }, `tail-${index}-${token.type}-${token.raw ?? token.text ?? ''}`)))] }));
+}
+function paddedContentWidth(width, paddingX) {
+    return width === undefined ? undefined : Math.max(1, width - paddingX * 2);
+}
+export function TerminalInlineMarkdown({ text, theme = defaultTerminalMarkdownTheme }) {
+    return (_jsx(Text, { color: theme.text, children: _jsx(InlineTokens, { tokens: undefined, fallback: text, theme: theme }) }));
+}
+function parseMarkdownTokens(text) {
+    if (text.length === 0) {
+        return [];
+    }
+    if (!markdownSyntaxPattern.test(text.slice(0, 500))) {
+        return text.split(/\r?\n/).map(line => ({ type: line.trim().length === 0 ? 'space' : 'paragraph', text: line, raw: line }));
+    }
+    return marked.lexer(text, { gfm: true, breaks: false });
+}
+function splitStableMarkdownPrefix(text) {
+    const boundary = lastStableBlockBoundary(text);
+    if (boundary <= 0 || boundary >= text.length) {
+        return { stable: '', tail: text };
+    }
+    return {
+        stable: text.slice(0, boundary),
+        tail: text.slice(boundary),
+    };
+}
+function lastStableBlockBoundary(text) {
+    if (hasUnclosedFence(text)) {
+        return text.lastIndexOf('\n```');
+    }
+    const paragraphBoundary = text.lastIndexOf('\n\n');
+    if (paragraphBoundary >= 0) {
+        return paragraphBoundary + 2;
+    }
+    const lineBoundary = text.lastIndexOf('\n');
+    return lineBoundary >= 0 ? lineBoundary + 1 : 0;
+}
+function hasUnclosedFence(text) {
+    const matches = text.match(/^```/gm);
+    return (matches?.length ?? 0) % 2 === 1;
+}
+function MarkdownBlockView({ token, theme, width, contentWidth, paddingX, }) {
+    if (token.type === 'hr') {
+        return _jsx(MarkdownTokenView, { token: token, theme: theme, width: width });
+    }
+    const rendered = _jsx(MarkdownTokenView, { token: token, theme: theme, width: contentWidth });
+    return paddingX > 0 ? (_jsx(Box, { flexDirection: "column", paddingX: paddingX, children: rendered })) : rendered;
+}
+function MarkdownTokenView({ token, theme, width }) {
+    if (token.type === 'space') {
+        return _jsx(Box, { height: 1 });
+    }
+    if (token.type === 'heading') {
+        return (_jsx(Text, { color: theme.accent, bold: true, children: inlineText(token.tokens, token.text) }));
+    }
+    if (token.type === 'paragraph' || token.type === 'text') {
+        const decorated = renderDecoratedPlainLine(token.text ?? token.raw ?? '', theme);
+        if (decorated) {
+            return decorated;
+        }
+        return (_jsx(Text, { wrap: "wrap", children: _jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? token.raw ?? '', theme: theme }) }));
+    }
+    if (token.type === 'list') {
+        return _jsx(MarkdownList, { token: token, theme: theme });
+    }
+    if (token.type === 'code') {
+        return _jsx(TerminalCodeBlock, { language: (token.lang ?? '').toLowerCase(), code: token.text ?? '', theme: theme, width: width });
+    }
+    if (token.type === 'table') {
+        return _jsx(MarkdownTable, { header: token.header ?? [], rows: token.rows ?? [], raw: token.raw, theme: theme, width: width });
+    }
+    if (token.type === 'blockquote') {
+        const quoteTheme = quoteThemeFor(theme);
+        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: theme.muted, children: "\u2502 " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: (token.tokens ?? []).map((child, index) => (_jsx(MarkdownTokenView, { token: child, theme: quoteTheme, width: width ? Math.max(0, width - 2) : undefined }, `${index}-${child.type}-${child.raw ?? child.text ?? ''}`))) })] }));
+    }
+    if (token.type === 'hr') {
+        return _jsx(Text, { color: theme.muted, wrap: "truncate-end", children: '─'.repeat(Math.max(1, width ?? 40)) });
+    }
+    return (_jsx(Text, { wrap: "wrap", children: _jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? token.raw ?? '', theme: theme }) }));
+}
+function MarkdownList({ token, theme }) {
+    const start = typeof token.start === 'number' ? token.start : 1;
+    return (_jsx(_Fragment, { children: (token.items ?? []).map((item, index) => {
+            const marker = token.ordered ? `${start + index}.` : '·';
+            const markerColor = token.ordered ? theme.orderedListMarker : theme.accent;
+            const content = inlineText(item.tokens, item.text ?? item.raw ?? '').replace(/\n+$/g, '');
+            const [firstLine = '', ...continuationLines] = content.split(/\r?\n/);
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { children: "  " }), _jsxs(Text, { color: markerColor, children: [marker, ' '] }), continuationLines.length === 0 ? (_jsx(InlineTokens, { tokens: item.tokens, fallback: content, theme: theme })) : (_jsx(InlineTokens, { tokens: undefined, fallback: firstLine, theme: theme }))] }), continuationLines.map((line, lineIndex) => (_jsx(DecoratedPlainLine, { line: line, theme: theme }, `${lineIndex}-${line}`)))] }, `${index}-${content}`));
+        }) }));
+}
+function renderDecoratedPlainLine(line, theme) {
+    if (!isDecoratedPlainLine(line)) {
+        return undefined;
+    }
+    return _jsx(DecoratedPlainLine, { line: line, theme: theme });
+}
+function DecoratedPlainLine({ line, theme }) {
+    const ordered = /^(\s*)((?:\d+(?:\.\d+)*[.、])|(?:[一二三四五六七八九十]+、))\s*(.+)$/.exec(line);
+    if (ordered?.[2] && ordered[3]) {
+        return (_jsxs(Text, { wrap: "wrap", children: [_jsx(Text, { children: "  " }), _jsxs(Text, { color: theme.orderedListMarker, children: [ordered[2], ' '] }), _jsx(InlineTokens, { tokens: undefined, fallback: ordered[3], theme: theme })] }));
+    }
+    return (_jsx(Text, { wrap: "wrap", children: _jsx(InlineTokens, { tokens: undefined, fallback: line, theme: theme }) }));
+}
+function isDecoratedPlainLine(line) {
+    return /^(\s*)((?:\d+(?:\.\d+)*[.、])|(?:[一二三四五六七八九十]+、))\s*(.+)$/.test(line);
+}
+function InlineTokens({ tokens, fallback, theme, style = defaultInlineStyle, }) {
+    const effectiveTokens = tokens?.length ? tokens : splitFallbackInlineTokens(fallback);
+    return (_jsx(_Fragment, { children: effectiveTokens.map((token, index) => (_jsx(InlineTokenView, { token: token, theme: theme, style: style }, `${index}-${token.type}-${token.raw ?? token.text ?? ''}`))) }));
+}
+const defaultInlineStyle = {
+    bold: false,
+    italic: false,
+    underline: false,
+};
+function InlineTokenView({ token, theme, style, }) {
+    if (token.type === 'codespan') {
+        return _jsx(StyledInlineText, { text: token.text ?? '', theme: theme, style: withInlineStyle(defaultInlineStyle, { color: theme.accent }) });
+    }
+    if (token.type === 'strong_em') {
+        return (_jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? '', theme: theme, style: withInlineStyle(style, { bold: true, italic: true, underline: true, color: theme.strongEmphasis }) }));
+    }
+    if (token.type === 'strong') {
+        return _jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? '', theme: theme, style: withInlineStyle(style, { bold: true, color: theme.strong }) });
+    }
+    if (token.type === 'em') {
+        return (_jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? '', theme: theme, style: withInlineStyle(style, { italic: true, underline: true, color: theme.emphasis }) }));
+    }
+    if (token.type === 'link') {
+        const linkStyle = withInlineStyle(style, { color: theme.accent });
+        if (token.tokens?.length) {
+            return _jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? token.href ?? '', theme: theme, style: linkStyle });
+        }
+        return _jsx(StyledInlineText, { text: token.text ?? token.href ?? '', theme: theme, style: linkStyle });
+    }
+    if (token.type === 'br') {
+        return _jsx(Text, { children: '\n' });
+    }
+    if (token.tokens?.length) {
+        return _jsx(InlineTokens, { tokens: token.tokens, fallback: token.text ?? '', theme: theme, style: style });
+    }
+    return _jsx(StyledInlineText, { text: token.text ?? token.raw ?? '', theme: theme, style: style });
+}
+function StyledInlineText({ text, theme, style }) {
+    return (_jsx(Text, { color: style.color ?? theme.text, ...(style.bold ? { bold: true } : {}), ...(style.italic ? { italic: true } : {}), ...(style.underline ? { underline: true } : {}), children: text }));
+}
+function withInlineStyle(style, patch) {
+    const next = {
+        bold: patch.bold ?? style.bold,
+        italic: patch.italic ?? style.italic,
+        underline: patch.underline ?? style.underline,
+    };
+    const color = patch.color ?? style.color;
+    if (color !== undefined) {
+        next.color = color;
+    }
+    return next;
+}
+function splitFallbackInlineTokens(text) {
+    const tokens = [];
+    let index = 0;
+    let plainStart = 0;
+    const flushPlain = (end) => {
+        if (end > plainStart) {
+            tokens.push({ type: 'text', text: text.slice(plainStart, end) });
+        }
+    };
+    while (index < text.length) {
+        const marker = inlineMarkerAt(text, index);
+        if (!marker) {
+            index += 1;
+            continue;
+        }
+        const end = text.indexOf(marker.raw, index + marker.raw.length);
+        if (end < 0 || end === index + marker.raw.length) {
+            index += marker.raw.length;
+            continue;
+        }
+        flushPlain(index);
+        tokens.push({ type: marker.type, text: text.slice(index + marker.raw.length, end) });
+        index = end + marker.raw.length;
+        plainStart = index;
+    }
+    flushPlain(text.length);
+    return tokens.length > 0 ? tokens : [{ type: 'text', text }];
+}
+function inlineMarkerAt(text, index) {
+    if (text.startsWith('`', index)) {
+        return { raw: '`', type: 'codespan' };
+    }
+    if (text.startsWith('***', index)) {
+        return { raw: '***', type: 'strong_em' };
+    }
+    if (text.startsWith('**', index)) {
+        return { raw: '**', type: 'strong' };
+    }
+    if (text.startsWith('*', index)) {
+        return { raw: '*', type: 'em' };
+    }
+    return undefined;
+}
+function inlineText(tokens, fallback) {
+    if (!tokens?.length) {
+        return fallback ?? '';
+    }
+    return tokens.map(token => inlineText(token.tokens, token.text ?? token.raw ?? '')).join('');
+}
+export function MarkdownTable({ header, rows, raw, theme = defaultTerminalMarkdownTheme, width, }) {
+    const parsedRawTable = parseRawMarkdownTable(raw, header.length);
+    const shouldUseRawTable = parsedRawTable?.hadExtraCells === true;
+    const normalizedHeader = shouldUseRawTable ? parsedRawTable.header : header.map(cellText);
+    const normalizedRows = shouldUseRawTable ? parsedRawTable.rows : rows.map(row => row.map(cellText));
+    const columnCount = Math.max(normalizedHeader.length, ...normalizedRows.map(row => row.length), 0);
+    const tableRows = [normalizeTableRow(normalizedHeader, columnCount), ...normalizedRows.map(row => normalizeTableRow(row, columnCount))];
+    const widths = tableColumnWidths(tableRows, width);
+    const renderedLines = [
+        tableBorder('top', widths),
+        ...wrappedTableRow(tableRows[0] ?? [], widths),
+        tableBorder('middle', widths),
+        ...tableRows.slice(1).flatMap(row => wrappedTableRow(row, widths)),
+        tableBorder('bottom', widths),
+    ];
+    return (_jsx(Box, { flexDirection: "column", children: renderedLines.map((line, index) => (_jsx(Text, { color: theme.text, children: line }, `${index}-${line}`))) }));
+}
+function cellText(cell) {
+    return inlineText(cell.tokens, cell.text ?? '');
+}
+function parseRawMarkdownTable(raw, expectedColumnCount) {
+    if (!raw || expectedColumnCount <= 0) {
+        return undefined;
+    }
+    const lines = raw.trim().split(/\r?\n/).filter(line => line.trim().length > 0);
+    if (lines.length < 2) {
+        return undefined;
+    }
+    const header = mergeMarkdownTableCells(splitMarkdownTableLine(lines[0] ?? ''), expectedColumnCount);
+    let hadExtraCells = false;
+    const rows = lines.slice(2).map(line => {
+        const cells = splitMarkdownTableLine(line);
+        if (cells.length > expectedColumnCount) {
+            hadExtraCells = true;
+        }
+        return mergeMarkdownTableCells(cells, expectedColumnCount);
+    });
+    return { header, rows, hadExtraCells };
+}
+function splitMarkdownTableLine(line) {
+    const trimmed = line.trim();
+    const withoutLeadingPipe = trimmed.startsWith('|') ? trimmed.slice(1) : trimmed;
+    const content = withoutLeadingPipe.endsWith('|') && !isEscapedPipe(withoutLeadingPipe, withoutLeadingPipe.length - 1)
+        ? withoutLeadingPipe.slice(0, -1)
+        : withoutLeadingPipe;
+    const cells = [];
+    let current = '';
+    for (let index = 0; index < content.length; index += 1) {
+        const char = content[index];
+        if (char === '\\' && content[index + 1] === '|') {
+            current += '|';
+            index += 1;
+            continue;
+        }
+        if (char === '|') {
+            cells.push(current);
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    cells.push(current);
+    return cells;
+}
+function mergeMarkdownTableCells(cells, expectedColumnCount) {
+    if (cells.length <= expectedColumnCount) {
+        return normalizeTableRow(cells.map(cell => markdownInlinePlainText(cell.trim())), expectedColumnCount);
+    }
+    const leadingCells = cells.slice(0, expectedColumnCount - 1).map(cell => markdownInlinePlainText(cell.trim()));
+    const mergedTail = markdownInlinePlainText(cells.slice(expectedColumnCount - 1).join('|').trim());
+    return normalizeTableRow([...leadingCells, mergedTail], expectedColumnCount);
+}
+function markdownInlinePlainText(value) {
+    if (value.length === 0) {
+        return '';
+    }
+    const tokens = marked.lexer(value, { gfm: true, breaks: false });
+    return tokens.map(token => inlineText(token.tokens, token.text ?? token.raw ?? '')).join(' ');
+}
+function isEscapedPipe(value, index) {
+    let slashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && value[cursor] === '\\'; cursor -= 1) {
+        slashCount += 1;
+    }
+    return slashCount % 2 === 1;
+}
+export function TerminalCodeBlock({ language, code, theme = defaultTerminalMarkdownTheme, width, }) {
+    const lines = code.length > 0 ? code.split(/\r?\n/) : [];
+    const normalizedLanguage = normalizeCodeLanguage(language, lines);
+    if (normalizedLanguage === 'diff') {
+        return _jsx(StructuredDiffView, { diff: code, theme: theme, width: width });
+    }
+    if (normalizedLanguage === 'shell') {
+        return _jsx(ShellCommandView, { command: code, theme: theme, width: width });
+    }
+    const isPlain = normalizedLanguage === 'plain' || normalizedLanguage === 'tree';
+    const highlightedLines = useMemo(() => (isPlain ? [] : highlightCodeBlock(code, normalizedLanguage, theme)), [code, normalizedLanguage, theme, isPlain]);
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, index) => (isPlain ? (_jsx(Box, { children: _jsx(CodeLine, { language: normalizedLanguage, line: line, theme: theme, parts: highlightedLines[index], width: width }) }, `${index}-${line}`)) : (_jsx(Box, { children: _jsx(CodeLine, { language: normalizedLanguage, line: line, theme: theme, parts: highlightedLines[index], width: width }) }, `${index}-${line}`)))) }));
+}
+function CodeLine({ language, line, theme, parts, width, }) {
+    const sourceParts = language === 'plain' || language === 'tree'
+        ? [{ text: line, color: theme.text }]
+        : parts ?? [{ text: line, color: theme.text }];
+    const renderedParts = expandTabsInCodeParts(sourceParts);
+    const contentWidth = safeLineWidth(codePanelContentWidth(width));
+    const visibleParts = contentWidth === undefined ? renderedParts : truncateCodePartsToDisplayWidth(renderedParts, contentWidth);
+    const padding = contentWidth === undefined ? '' : ' '.repeat(Math.max(0, contentWidth - codePartsDisplayWidth(visibleParts)));
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: codePanelPadding }), _jsxs(Text, { wrap: "truncate-end", backgroundColor: theme.codeBackground, children: [visibleParts.map((part, index) => (_jsx(CodePartText, { part: part, backgroundColor: theme.codeBackground, wrap: "truncate-end" }, `${index}-${part.text}`))), padding] })] }));
+}
+export function StructuredDiffView({ diff, theme = defaultTerminalMarkdownTheme, language, width, }) {
+    const lines = diff.split(/\r?\n/);
+    const structuredLines = parseStructuredDiffPreview(lines);
+    if (structuredLines) {
+        return _jsx(StructuredDiffPreview, { lines: structuredLines, theme: theme, language: language, width: width });
+    }
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, index) => (_jsx(Box, { children: _jsx(DiffLine, { line: line, theme: theme, width: width }) }, `${index}-${line}`))) }));
+}
+export function isStructuredDiffPreviewText(diff) {
+    return Boolean(parseStructuredDiffPreview(diff.split(/\r?\n/)));
+}
+function parseStructuredDiffPreview(lines) {
+    if (lines.length === 0) {
+        return undefined;
+    }
+    const parsed = [];
+    let matched = 0;
+    for (const line of lines) {
+        const omissionText = normalizeOmissionLine(line);
+        if (omissionText) {
+            parsed.push({ kind: 'ellipsis', text: omissionText });
+            matched += 1;
+            continue;
+        }
+        const bareLineNumberMatch = /^(\s*\d+)\s*$/.exec(line);
+        if (bareLineNumberMatch?.[1]) {
+            parsed.push({ kind: 'same', lineNumber: Number(bareLineNumberMatch[1].trim()), text: '' });
+            matched += 1;
+            continue;
+        }
+        const match = /^(\s*\d+)( [+\-] | {3})(.*)$/.exec(line);
+        if (!match?.[1] || match[2] === undefined) {
+            return undefined;
+        }
+        const marker = match[2][1] ?? ' ';
+        parsed.push({
+            kind: marker === '+' ? 'add' : marker === '-' ? 'remove' : 'same',
+            lineNumber: Number(match[1].trim()),
+            text: match[3] ?? '',
+        });
+        matched += 1;
+    }
+    return matched > 0 ? parsed : undefined;
+}
+function normalizeOmissionLine(line) {
+    if (line === omissionMarker || line === '...') {
+        return omissionMarker;
+    }
+    const legacyCountMatch = /^\.\.\. (\d+) diff lines omitted \.\.\.$/.exec(line);
+    if (legacyCountMatch?.[1]) {
+        return `${omissionMarker} ${legacyCountMatch[1]} diff lines omitted`;
+    }
+    const countMatch = /^⋮ (\d+) diff lines omitted$/.exec(line);
+    if (countMatch) {
+        return line;
+    }
+    return undefined;
+}
+function StructuredDiffPreview({ lines, theme, language, width, }) {
+    const lineNumberWidth = structuredDiffLineNumberWidth(lines);
+    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, index) => (_jsx(StructuredDiffPreviewRow, { line: line, theme: theme, language: language, width: width, lineNumberWidth: lineNumberWidth }, `${index}-${line.kind}-${line.lineNumber ?? ''}-${line.text}`))) }));
+}
+function StructuredDiffPreviewRow({ line, theme, language, width, lineNumberWidth, }) {
+    if (line.kind === 'ellipsis') {
+        return _jsx(FullWidthText, { text: line.text, color: theme.muted, backgroundColor: theme.codeBackground, width: width });
+    }
+    const backgroundColor = line.kind === 'add' ? theme.diffAddBackground : line.kind === 'remove' ? theme.diffRemoveBackground : theme.codeBackground;
+    const marker = line.kind === 'add' ? '+' : line.kind === 'remove' ? '-' : ' ';
+    const markerColor = line.kind === 'add' ? theme.success : line.kind === 'remove' ? theme.danger : theme.muted;
+    const lineNumber = String(line.lineNumber ?? '').padEnd(lineNumberWidth);
+    const codeParts = diffCodeParts(line.text, language, theme);
+    const safeWidth = safeLineWidth(codePanelContentWidth(width));
+    const prefixWidth = displayWidth(lineNumber) + 3;
+    const visibleCodeParts = safeWidth === undefined ? codeParts : truncateCodePartsToDisplayWidth(codeParts, Math.max(0, safeWidth - prefixWidth));
+    const visibleWidth = prefixWidth + codePartsDisplayWidth(visibleCodeParts);
+    const padding = safeWidth === undefined ? '' : ' '.repeat(Math.max(0, safeWidth - visibleWidth));
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: codePanelPadding }), _jsxs(Text, { backgroundColor: backgroundColor, wrap: "truncate-end", children: [_jsxs(Text, { color: theme.muted, backgroundColor: backgroundColor, children: [lineNumber, " "] }), _jsx(Text, { color: markerColor, backgroundColor: backgroundColor, children: marker }), _jsx(Text, { color: theme.muted, backgroundColor: backgroundColor, children: " " }), _jsx(DiffCodeParts, { parts: visibleCodeParts, backgroundColor: backgroundColor }), padding] })] }));
+}
+function structuredDiffLineNumberWidth(lines) {
+    return lines.reduce((max, line) => {
+        if (line.kind === 'ellipsis') {
+            return max;
+        }
+        return Math.max(max, displayWidth(String(line.lineNumber ?? '')));
+    }, 1);
+}
+function diffCodeParts(text, language, theme) {
+    const expandedText = expandTabs(text);
+    const normalizedLanguage = language ? normalizeCodeLanguage(language, [expandedText]) : 'plain';
+    return normalizedLanguage === 'plain' || normalizedLanguage === 'tree' ? [{ text: expandedText, color: theme.text }] : highlightCodeLine(expandedText, normalizedLanguage, theme);
+}
+function DiffCodeParts({ parts, backgroundColor }) {
+    return (_jsx(_Fragment, { children: parts.map((part, index) => (_jsx(CodePartText, { part: part, backgroundColor: backgroundColor, wrap: "truncate-end" }, `${index}-${part.text}`))) }));
+}
+function DiffLine({ line, theme, width }) {
+    if (line.startsWith('+')) {
+        return _jsx(FullWidthText, { text: line, color: theme.text, backgroundColor: theme.diffAddBackground, width: width });
+    }
+    if (line.startsWith('-')) {
+        return _jsx(FullWidthText, { text: line, color: theme.text, backgroundColor: theme.diffRemoveBackground, width: width });
+    }
+    if (line.startsWith('@@')) {
+        return (_jsxs(Text, { children: [_jsx(Text, { children: codePanelPadding }), _jsx(Text, { color: theme.accent, children: line })] }));
+    }
+    if (line.startsWith('diff ') || line.startsWith('index ')) {
+        return (_jsxs(Text, { children: [_jsx(Text, { children: codePanelPadding }), _jsx(Text, { color: theme.muted, children: line })] }));
+    }
+    return _jsx(FullWidthText, { text: line, color: theme.text, backgroundColor: theme.codeBackground, width: width });
+}
+function FullWidthText({ text, color, backgroundColor, width, }) {
+    const safeWidth = safeLineWidth(codePanelContentWidth(width));
+    const expandedText = expandTabs(text);
+    const visibleText = safeWidth === undefined ? expandedText : truncateTextToDisplayWidth(expandedText, safeWidth);
+    const padding = safeWidth === undefined ? '' : ' '.repeat(Math.max(0, safeWidth - displayWidth(visibleText)));
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: codePanelPadding }), _jsxs(Text, { wrap: "truncate-end", color: color, backgroundColor: backgroundColor, children: [visibleText, padding] })] }));
+}
+function codePanelContentWidth(width) {
+    return width === undefined ? undefined : Math.max(0, width - displayWidth(codePanelPadding));
+}
+function safeLineWidth(width) {
+    if (width === undefined) {
+        return undefined;
+    }
+    // Leave two terminal cells free to avoid hard autowrap after full-width background rows in nested Ink layouts.
+    return Math.max(1, width - 2);
+}
+export function ShellCommandView({ command, theme = defaultTerminalMarkdownTheme, width, }) {
+    return (_jsx(Box, { flexDirection: "column", children: command.split(/\r?\n/).map((line, index) => (_jsx(ShellCommandLine, { line: line, theme: theme, width: width }, `${index}-${line}`))) }));
+}
+export function ShellInlineCommand({ command, theme = defaultTerminalMarkdownTheme, }) {
+    const parts = highlightShellLine(command, theme);
+    return (_jsx(_Fragment, { children: parts.map((part, index) => (_jsx(CodePartText, { part: part, wrap: "wrap" }, `${index}-${part.text}`))) }));
+}
+function ShellCommandLine({ line, theme, width }) {
+    const parts = highlightShellLine(line, theme);
+    const contentWidth = safeLineWidth(codePanelContentWidth(width));
+    const visibleParts = contentWidth === undefined ? parts : truncateCodePartsToDisplayWidth(parts, contentWidth);
+    const padding = contentWidth === undefined ? '' : ' '.repeat(Math.max(0, contentWidth - codePartsDisplayWidth(visibleParts)));
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { children: codePanelPadding }), _jsxs(Text, { wrap: "truncate-end", backgroundColor: theme.codeBackground, children: [visibleParts.map((part, partIndex) => (_jsx(CodePartText, { part: part, backgroundColor: theme.codeBackground, wrap: "truncate-end" }, `${partIndex}-${part.text}`))), padding] })] }));
+}
+function expandTabsInCodeParts(parts, tabSize = codeTabSize) {
+    const expanded = [];
+    let column = 0;
+    for (const part of parts) {
+        let text = '';
+        for (const char of part.text) {
+            if (char === '\t') {
+                const spaces = tabSize - (column % tabSize);
+                text += ' '.repeat(spaces);
+                column += spaces;
+                continue;
+            }
+            text += char;
+            column += displayWidth(char);
+        }
+        expanded.push({ ...part, text });
+    }
+    return expanded;
+}
+function expandTabs(value, tabSize = codeTabSize) {
+    let expanded = '';
+    let column = 0;
+    for (const char of value) {
+        if (char === '\t') {
+            const spaces = tabSize - (column % tabSize);
+            expanded += ' '.repeat(spaces);
+            column += spaces;
+            continue;
+        }
+        expanded += char;
+        column += displayWidth(char);
+    }
+    return expanded;
+}
+function codePartsDisplayWidth(parts) {
+    return parts.reduce((width, part) => width + displayWidth(part.text), 0);
+}
+function truncateCodePartsToDisplayWidth(parts, maxWidth) {
+    if (maxWidth <= 0) {
+        return [];
+    }
+    const truncated = [];
+    let usedWidth = 0;
+    for (const part of parts) {
+        if (usedWidth >= maxWidth) {
+            break;
+        }
+        const text = truncateTextToDisplayWidth(part.text, maxWidth - usedWidth);
+        if (text.length > 0) {
+            truncated.push({ ...part, text });
+            usedWidth += displayWidth(text);
+        }
+    }
+    return truncated;
+}
+function truncateTextToDisplayWidth(value, maxWidth) {
+    if (maxWidth <= 0) {
+        return '';
+    }
+    let text = '';
+    let usedWidth = 0;
+    for (const char of value) {
+        const charWidth = displayWidth(char);
+        if (usedWidth + charWidth > maxWidth) {
+            break;
+        }
+        text += char;
+        usedWidth += charWidth;
+    }
+    return text;
+}
+function CodePartText({ part, backgroundColor, wrap }) {
+    return (_jsx(Text, { color: part.color, ...(wrap ? { wrap } : {}), ...(part.bold ? { bold: true } : {}), ...(part.italic ? { italic: true } : {}), ...(part.underline ? { underline: true } : {}), ...(backgroundColor ? { backgroundColor } : {}), children: part.text }));
+}
+function highlightCodeBlock(code, language, theme) {
+    const lines = code.length > 0 ? code.split(/\r?\n/) : [];
+    if (!hljs.getLanguage(language) || code.length === 0 || code.length > maxHighlightJsBlockLength) {
+        return lines.map(line => highlightCodeLine(line, language, theme));
+    }
+    const cacheKey = highlightBlockCacheKey(code, language, theme);
+    const cached = highlightBlockCache.get(cacheKey);
+    if (cached) {
+        highlightBlockCache.delete(cacheKey);
+        highlightBlockCache.set(cacheKey, cached);
+        return cached;
+    }
+    try {
+        const html = hljs.highlight(code, { language, ignoreIllegals: true }).value;
+        const highlightedLines = splitCodePartsIntoLines(htmlToCodeParts(html, theme), lines.length, theme);
+        return cacheHighlightBlock(cacheKey, highlightedLines);
+    }
+    catch {
+        return lines.map(line => highlightCodeLine(line, language, theme));
+    }
+}
+function splitCodePartsIntoLines(parts, lineCount, theme) {
+    const lines = [[]];
+    for (const part of parts) {
+        const chunks = part.text.split(/\r?\n/);
+        for (let index = 0; index < chunks.length; index += 1) {
+            if (index > 0) {
+                lines.push([]);
+            }
+            const chunk = chunks[index] ?? '';
+            if (chunk.length > 0) {
+                lines[lines.length - 1]?.push({ ...part, text: chunk });
+            }
+        }
+    }
+    while (lines.length < lineCount) {
+        lines.push([]);
+    }
+    return lines.slice(0, lineCount).map(line => line.length > 0 ? line : [{ text: '', color: theme.text }]);
+}
+function highlightBlockCacheKey(code, language, theme) {
+    return [
+        'block',
+        language,
+        code.length,
+        hashContent(code),
+        theme.text,
+        theme.muted,
+        theme.accent,
+        theme.success,
+        theme.danger,
+        theme.warning,
+        theme.codeKeyword,
+        theme.codeString,
+        theme.codeNumber,
+        theme.codeComment,
+        theme.codeType,
+        theme.codeTitle,
+        theme.codeFunction,
+        theme.codeVariable,
+        theme.codeProperty,
+        theme.codeOperator,
+        theme.codeMeta,
+        theme.codeSection,
+        theme.codeRegexp,
+        theme.codePunctuation,
+    ].join('\u0000');
+}
+function cacheHighlightBlock(key, parts) {
+    highlightBlockCache.set(key, parts);
+    if (highlightBlockCache.size > maxHighlightBlockCacheEntries) {
+        const firstKey = highlightBlockCache.keys().next().value;
+        if (firstKey) {
+            highlightBlockCache.delete(firstKey);
+        }
+    }
+    return parts;
+}
+function highlightCodeLine(line, language, theme) {
+    const cacheKey = highlightCacheKey(line, language, theme);
+    const cached = highlightLineCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const highlightParts = highlightJsLine(line, language, theme);
+    if (highlightParts.length > 0) {
+        return cacheHighlightParts(cacheKey, highlightParts);
+    }
+    if (line.trim().length === 0) {
+        return [{ text: line, color: theme.text }];
+    }
+    const commentIndex = codeCommentIndex(line, language);
+    if (commentIndex === 0) {
+        return cacheHighlightParts(cacheKey, [{ text: line, color: theme.codeComment, italic: true }]);
+    }
+    if (commentIndex > 0) {
+        return cacheHighlightParts(cacheKey, [
+            ...highlightCodeLineWithoutComment(line.slice(0, commentIndex), language, theme),
+            { text: line.slice(commentIndex), color: theme.codeComment, italic: true },
+        ]);
+    }
+    return cacheHighlightParts(cacheKey, highlightCodeLineWithoutComment(line, language, theme));
+}
+function highlightJsLine(line, language, theme) {
+    if (!hljs.getLanguage(language) || line.trim().length === 0 || line.length > maxHighlightJsLineLength) {
+        return [];
+    }
+    try {
+        const html = hljs.highlight(line, { language, ignoreIllegals: true }).value;
+        return htmlToCodeParts(html, theme);
+    }
+    catch {
+        return [];
+    }
+}
+function highlightCacheKey(line, language, theme) {
+    return [
+        language,
+        theme.text,
+        theme.muted,
+        theme.accent,
+        theme.success,
+        theme.danger,
+        theme.warning,
+        theme.codeKeyword,
+        theme.codeString,
+        theme.codeNumber,
+        theme.codeComment,
+        theme.codeType,
+        theme.codeTitle,
+        theme.codeFunction,
+        theme.codeVariable,
+        theme.codeProperty,
+        theme.codeOperator,
+        theme.codeMeta,
+        theme.codeSection,
+        theme.codeRegexp,
+        theme.codePunctuation,
+        line,
+    ].join('\u0000');
+}
+function cacheHighlightParts(key, parts) {
+    highlightLineCache.set(key, parts);
+    if (highlightLineCache.size > maxHighlightCacheEntries) {
+        const firstKey = highlightLineCache.keys().next().value;
+        if (firstKey) {
+            highlightLineCache.delete(firstKey);
+        }
+    }
+    return parts;
+}
+function quoteThemeFor(theme) {
+    return {
+        ...theme,
+        text: theme.quoteText,
+        accent: theme.quoteText,
+        success: theme.quoteText,
+        danger: theme.quoteText,
+        warning: theme.quoteText,
+        emphasis: theme.quoteText,
+        strong: theme.quoteText,
+        strongEmphasis: theme.quoteText,
+        orderedListMarker: theme.quoteText,
+        codeBackground: theme.codeBackground,
+        codeKeyword: theme.quoteText,
+        codeString: theme.quoteText,
+        codeNumber: theme.quoteText,
+        codeComment: theme.quoteText,
+        codeType: theme.quoteText,
+        codeTitle: theme.quoteText,
+        codeFunction: theme.quoteText,
+        codeVariable: theme.quoteText,
+        codeProperty: theme.quoteText,
+        codeOperator: theme.quoteText,
+        codeMeta: theme.quoteText,
+        codeSection: theme.quoteText,
+        codeRegexp: theme.quoteText,
+        codePunctuation: theme.quoteText,
+    };
+}
+function htmlToCodeParts(html, theme) {
+    const parts = [];
+    const spanPattern = /<span class="hljs-([^"]+)">([\s\S]*?)<\/span>/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = spanPattern.exec(html)) !== null) {
+        if (match.index > lastIndex) {
+            parts.push({ text: decodeHtml(stripHtml(html.slice(lastIndex, match.index))), color: theme.text });
+        }
+        const className = match[1] ?? '';
+        const content = decodeHtml(stripHtml(match[2] ?? ''));
+        parts.push({ text: content, ...styleForHighlightClass(className, theme) });
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < html.length) {
+        parts.push({ text: decodeHtml(stripHtml(html.slice(lastIndex))), color: theme.text });
+    }
+    return parts.filter(part => part.text.length > 0);
+}
+function styleForHighlightClass(className, theme) {
+    if (/(comment|quote)/.test(className)) {
+        return { color: theme.codeComment, italic: true };
+    }
+    if (/(keyword|selector-tag|doctag)/.test(className)) {
+        return { color: theme.codeKeyword };
+    }
+    if (/(built_in|builtin-name)/.test(className)) {
+        return { color: theme.codeType };
+    }
+    if (/(type|class)/.test(className)) {
+        return { color: theme.codeType };
+    }
+    if (/(title|name)/.test(className) && /function_/.test(className)) {
+        return { color: theme.codeFunction };
+    }
+    if (/(title|name|selector-id|selector-class)/.test(className)) {
+        return { color: theme.codeTitle };
+    }
+    if (/(string|symbol|template-variable|template-tag)/.test(className)) {
+        return { color: theme.codeString };
+    }
+    if (/(regexp)/.test(className)) {
+        return { color: theme.codeRegexp };
+    }
+    if (/(number|literal)/.test(className)) {
+        return { color: theme.codeNumber };
+    }
+    if (/(attr|attribute|property|params|variable)/.test(className)) {
+        return { color: theme.codeVariable };
+    }
+    if (/(meta|meta-keyword|meta-string)/.test(className)) {
+        return { color: theme.codeMeta };
+    }
+    if (/(section|bullet|addition)/.test(className)) {
+        return { color: theme.codeSection };
+    }
+    if (/(deletion)/.test(className)) {
+        return { color: theme.danger };
+    }
+    if (/(operator|subst)/.test(className)) {
+        return { color: theme.codeOperator };
+    }
+    if (/(punctuation)/.test(className)) {
+        return { color: theme.codePunctuation };
+    }
+    if (/(emphasis)/.test(className)) {
+        return { color: theme.emphasis, italic: true, underline: true };
+    }
+    if (/(strong)/.test(className)) {
+        return { color: theme.strong };
+    }
+    return { color: theme.text };
+}
+function stripHtml(value) {
+    return value.replace(/<[^>]+>/g, '');
+}
+function decodeHtml(value) {
+    return value
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#39;/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&');
+}
+function hashContent(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+function highlightShellLine(line, theme) {
+    const commentIndex = line.indexOf('#');
+    if (commentIndex === 0 || line.trimStart().startsWith('#')) {
+        return [{ text: line, color: theme.codeComment, italic: true }];
+    }
+    const prefix = commentIndex > 0 ? line.slice(0, commentIndex) : line;
+    const suffix = commentIndex > 0 ? line.slice(commentIndex) : '';
+    const parts = [];
+    const pattern = /("(?:\\.|[^"])*"|'(?:\\.|[^'])*'|`(?:\\.|[^`])*`|--?[A-Za-z0-9][\w-]*|\b[A-Za-z_][\w.-]*\b|\d+)/g;
+    let lastIndex = 0;
+    let sawCommand = false;
+    let match;
+    while ((match = pattern.exec(prefix)) !== null) {
+        if (match.index > lastIndex) {
+            parts.push({ text: prefix.slice(lastIndex, match.index), color: theme.text });
+        }
+        const raw = match[0];
+        if (/^['"`]/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeString });
+        }
+        else if (/^--?/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeMeta });
+        }
+        else if (/^\d/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeNumber });
+        }
+        else if (!sawCommand && raw.trim().length > 0) {
+            parts.push({ text: raw, color: theme.codeFunction });
+            sawCommand = true;
+        }
+        else {
+            parts.push({ text: raw, color: theme.codeVariable });
+        }
+        lastIndex = match.index + raw.length;
+    }
+    if (lastIndex < prefix.length) {
+        parts.push({ text: prefix.slice(lastIndex), color: theme.text });
+    }
+    if (suffix) {
+        parts.push({ text: suffix, color: theme.codeComment, italic: true });
+    }
+    return parts.length > 0 ? parts : [{ text: line, color: theme.text }];
+}
+function highlightCodeLineWithoutComment(line, language, theme) {
+    const keywords = keywordsForLanguage(language);
+    const parts = [];
+    const pattern = /("(?:\\.|[^"])*"|'(?:\\.|[^'])*'|`(?:\\.|[^`])*`|=>|===|!==|==|!=|<=|>=|&&|\|\||[{}()[\].,:;<>+\-*/%=!&|?]|\b[A-Za-z_][\w]*\b|\b\d+(?:\.\d+)?\b)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(line)) !== null) {
+        if (match.index > lastIndex) {
+            parts.push({ text: line.slice(lastIndex, match.index), color: theme.text });
+        }
+        const raw = match[0];
+        if (/^['"`]/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeString });
+        }
+        else if (/^\d/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeNumber });
+        }
+        else if (keywords.has(raw)) {
+            parts.push({ text: raw, color: theme.codeKeyword });
+        }
+        else if (/^[{}()[\].,:;<>]$/.test(raw)) {
+            parts.push({ text: raw, color: theme.codePunctuation });
+        }
+        else if (/^(=>|===|!==|==|!=|<=|>=|&&|\|\||[+\-*/%=!&|?])$/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeOperator });
+        }
+        else if (line.slice(match.index + raw.length).trimStart().startsWith('(')) {
+            parts.push({ text: raw, color: theme.codeFunction });
+        }
+        else if (match.index > 0 && line[match.index - 1] === '.') {
+            parts.push({ text: raw, color: theme.codeProperty });
+        }
+        else if (/^[A-Z]/.test(raw)) {
+            parts.push({ text: raw, color: theme.codeType });
+        }
+        else {
+            parts.push({ text: raw, color: theme.codeVariable });
+        }
+        lastIndex = match.index + raw.length;
+    }
+    if (lastIndex < line.length) {
+        parts.push({ text: line.slice(lastIndex), color: theme.text });
+    }
+    return parts.length > 0 ? parts : [{ text: line, color: theme.text }];
+}
+function codeCommentIndex(line, language) {
+    if (language === 'python' || language === 'py' || language === 'ruby') {
+        return line.indexOf('#');
+    }
+    return line.indexOf('//');
+}
+function keywordsForLanguage(language) {
+    const common = ['return', 'if', 'else', 'for', 'while', 'break', 'continue', 'try', 'catch', 'throw', 'class', 'new'];
+    const byLanguage = {
+        go: ['package', 'import', 'func', 'var', 'const', 'type', 'struct', 'interface', 'map', 'range', 'defer', 'go', 'select', 'case', 'default'],
+        js: ['const', 'let', 'var', 'function', 'async', 'await', 'export', 'import', 'from', 'default', 'type', 'interface'],
+        jsx: ['const', 'let', 'var', 'function', 'async', 'await', 'export', 'import', 'from', 'default', 'type', 'interface'],
+        ts: ['const', 'let', 'var', 'function', 'async', 'await', 'export', 'import', 'from', 'default', 'type', 'interface'],
+        tsx: ['const', 'let', 'var', 'function', 'async', 'await', 'export', 'import', 'from', 'default', 'type', 'interface'],
+        python: ['def', 'import', 'from', 'as', 'with', 'lambda', 'yield', 'None', 'True', 'False', 'self'],
+        py: ['def', 'import', 'from', 'as', 'with', 'lambda', 'yield', 'None', 'True', 'False', 'self'],
+        java: ['public', 'private', 'protected', 'static', 'final', 'void', 'extends', 'implements'],
+        rust: ['fn', 'let', 'mut', 'pub', 'impl', 'trait', 'match', 'use', 'mod', 'crate'],
+    };
+    return new Set([...common, ...(byLanguage[language] ?? [])]);
+}
+function normalizeCodeLanguage(language, lines) {
+    if (language === 'diff' || looksLikeDiff(lines)) {
+        return 'diff';
+    }
+    if (language === 'bash' || language === 'sh' || language === 'shell' || language === 'zsh') {
+        return 'shell';
+    }
+    if (language === '' || language === 'text' || language === 'txt' || language === 'plain' || language === 'plaintext') {
+        return looksLikeTree(lines) ? 'tree' : 'plain';
+    }
+    if (language === 'tree') {
+        return 'tree';
+    }
+    return language;
+}
+function looksLikeDiff(lines) {
+    return lines.some(line => line.startsWith('@@') || line.startsWith('diff --git')) || lines.filter(line => /^[+-]/.test(line)).length >= 2;
+}
+function looksLikeTree(lines) {
+    return lines.some(line => /(^|\s)[├└│]──|^\s*[A-Za-z0-9_.-]+\/$/.test(line));
+}
+function normalizeTableRow(row, columnCount) {
+    return Array.from({ length: columnCount }, (_, index) => row[index] ?? '');
+}
+function tableColumnWidths(rows, maxTableWidth) {
+    const columnCount = Math.max(0, ...rows.map(row => row.length));
+    const naturalWidths = Array.from({ length: columnCount }, (_, columnIndex) => Math.max(1, ...rows.map(row => displayWidth(row[columnIndex] ?? ''))));
+    if (maxTableWidth === undefined || columnCount === 0 || tableDisplayWidth(naturalWidths) <= maxTableWidth) {
+        return naturalWidths;
+    }
+    const availableCellWidth = Math.max(columnCount, maxTableWidth - tableFrameWidth(columnCount));
+    const widths = [...naturalWidths];
+    let totalCellWidth = widths.reduce((sum, width) => sum + width, 0);
+    while (totalCellWidth > availableCellWidth && widths.some(width => width > 1)) {
+        let widestIndex = 0;
+        for (let index = 1; index < widths.length; index += 1) {
+            if ((widths[index] ?? 0) > (widths[widestIndex] ?? 0)) {
+                widestIndex = index;
+            }
+        }
+        widths[widestIndex] = Math.max(1, (widths[widestIndex] ?? 1) - 1);
+        totalCellWidth -= 1;
+    }
+    return widths;
+}
+function tableFrameWidth(columnCount) {
+    return columnCount * 3 + 1;
+}
+function tableDisplayWidth(widths) {
+    return widths.reduce((sum, width) => sum + width, 0) + tableFrameWidth(widths.length);
+}
+function tableBorder(kind, widths) {
+    const chars = kind === 'top'
+        ? ['┌', '┬', '┐']
+        : kind === 'middle'
+            ? ['├', '┼', '┤']
+            : ['└', '┴', '┘'];
+    return `${chars[0]}${widths.map(width => '─'.repeat(width + 2)).join(chars[1])}${chars[2]}`;
+}
+function tableRow(row, widths) {
+    return `│${row.map((cell, index) => ` ${padDisplay(cell, widths[index] ?? 1)} `).join('│')}│`;
+}
+function wrappedTableRow(row, widths) {
+    const wrappedCells = widths.map((width, index) => wrapTableCell(row[index] ?? '', width));
+    const rowHeight = Math.max(1, ...wrappedCells.map(lines => lines.length));
+    return Array.from({ length: rowHeight }, (_, lineIndex) => tableRow(wrappedCells.map(lines => lines[lineIndex] ?? ''), widths));
+}
+function wrapTableCell(value, width) {
+    const lines = [];
+    let current = '';
+    let currentWidth = 0;
+    const pushCurrent = () => {
+        lines.push(current.trimEnd());
+        current = '';
+        currentWidth = 0;
+    };
+    for (const char of value) {
+        if (char === '\n') {
+            pushCurrent();
+            continue;
+        }
+        const charWidth = displayWidth(char);
+        if (current.length > 0 && currentWidth + charWidth > width) {
+            pushCurrent();
+        }
+        if (current.length === 0 && /\s/u.test(char)) {
+            continue;
+        }
+        current += char;
+        currentWidth += charWidth;
+    }
+    if (current.length > 0 || lines.length === 0) {
+        pushCurrent();
+    }
+    return lines;
+}
+function padDisplay(value, width) {
+    return `${value}${' '.repeat(Math.max(0, width - displayWidth(value)))}`;
+}
+export function displayWidth(value) {
+    let width = 0;
+    for (const char of value) {
+        const codePoint = char.codePointAt(0) ?? 0;
+        if (codePoint === 0 ||
+            codePoint < 32 ||
+            (codePoint >= 0x7f && codePoint < 0xa0) ||
+            isZeroWidthCodePoint(codePoint)) {
+            continue;
+        }
+        width += isFullWidthCodePoint(codePoint) || isEmojiCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint === 0x200d ||
+        (codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f));
+}
+function isEmojiCodePoint(codePoint) {
+    return ((codePoint >= 0x1f000 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x2600 && codePoint <= 0x27bf));
+}
+function isFullWidthCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
+export function flattenText(node) {
+    if (typeof node === 'string' || typeof node === 'number') {
+        return String(node);
+    }
+    if (Array.isArray(node)) {
+        return node.map(flattenText).join('');
+    }
+    return '';
+}