@linghun/tui 0.1.0

package/dist/chunk-DTK5NBTV.js

@@ -0,0 +1,912 @@
+import {
+  StructuredDiff
+} from "./chunk-F43AMWLZ.js";
+import {
+  charWidth,
+  displayWidth,
+  wrapText
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/MessageMarkdown.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { highlight } from "cli-highlight";
+import { lexer } from "marked";
+import { createContext, useContext } from "react";
+import { memo, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var MessageResponseContext = createContext(false);
+function useInMessageResponse() {
+  return useContext(MessageResponseContext);
+}
+function MessageResponseProvider({
+  children
+}) {
+  return /* @__PURE__ */ jsx(MessageResponseContext.Provider, { value: true, children });
+}
+var INLINE_TOKEN_RE = /(`[^`\n]+`|\*\*[^*\n][^\n]*?\*\*|\*[^*\n][^\n]*?\*|\[[^\]\n]+\]\([^\s)\n]+\))/u;
+var ANSI_REGEX = /\x1B\[[0-9;]*m/gu;
+var TABLE_VERTICAL_FALLBACK_WIDTH = 48;
+var TABLE_MAX_COLUMN_WIDTH = 48;
+var TABLE_MIN_COLUMN_WIDTH = 6;
+var TABLE_MIN_ACCEPTABLE_COLUMN = 8;
+var MARKDOWN_TOKEN_CACHE_LIMIT = 128;
+var markdownTokenCache = /* @__PURE__ */ new Map();
+var codeHighlightCache = /* @__PURE__ */ new Map();
+var GIT_CRLF_WARNING_RE = /^\[stderr\]\s*warning:\s+in the working copy of .+ LF will be replaced by CRLF\b.*$/iu;
+function getCachedMarkdownTokens(text) {
+  const cached = markdownTokenCache.get(text);
+  if (cached) {
+    markdownTokenCache.delete(text);
+    markdownTokenCache.set(text, cached);
+    return cached;
+  }
+  const tokens = lexer(text);
+  markdownTokenCache.set(text, tokens);
+  trimCache(markdownTokenCache);
+  return tokens;
+}
+function getCachedHighlightedCodeLines(code, lang) {
+  const key = `${lang ?? ""}::${code}`;
+  const cached = codeHighlightCache.get(key);
+  if (cached) {
+    codeHighlightCache.delete(key);
+    codeHighlightCache.set(key, cached);
+    return cached;
+  }
+  const lines = highlightedCodeLines(code, lang);
+  codeHighlightCache.set(key, lines);
+  trimCache(codeHighlightCache);
+  return lines;
+}
+function trimCache(cache) {
+  while (cache.size > MARKDOWN_TOKEN_CACHE_LIMIT) {
+    const first = cache.keys().next().value;
+    if (!first) return;
+    cache.delete(first);
+  }
+}
+function stripLowValueDiagnosticNoise(text) {
+  return text.split("\n").filter((line) => !GIT_CRLF_WARNING_RE.test(line.trim())).join("\n");
+}
+function isRawDiffStart(lines, index) {
+  const line = lines[index] ?? "";
+  const nextLines = lines.slice(index + 1, index + 5);
+  if (/^diff --git\s+/u.test(line)) return true;
+  if (/^@@\s+-\d/u.test(line)) return true;
+  if (/^---\s+\S/u.test(line)) {
+    return nextLines.some((next) => /^\+\+\+\s+\S/u.test(next));
+  }
+  if (/^(?:new file mode|deleted file mode)\s+\d+/u.test(line)) {
+    return nextLines.some((next) => /^---\s+\S/u.test(next) || /^\+\+\+\s+\S/u.test(next));
+  }
+  return false;
+}
+function isRawDiffLine(line) {
+  return /^diff --git\s+/u.test(line) || /^(?:index|new file mode|deleted file mode|old mode|new mode)\b/u.test(line) || /^(?:copy from|copy to|rename from|rename to|similarity index|dissimilarity index)\b/u.test(
+    line
+  ) || /^---\s+\S/u.test(line) || /^\+\+\+\s+\S/u.test(line) || /^@@\s+-\d/u.test(line) || /^[+-]/u.test(line) || /^ /u.test(line) || /^\/u.test(line);
+}
+function isRawDiffBlock(lines) {
+  const hasHeaderPair = lines.some((line) => /^---\s+\S/u.test(line)) && lines.some((line) => /^\+\+\+\s+\S/u.test(line));
+  const hasHunk = lines.some((line) => /^@@\s+-\d/u.test(line));
+  const hasAdd = lines.some((line) => /^\+(?!\+\+)/u.test(line));
+  const hasRemove = lines.some((line) => /^-(?!--)/u.test(line));
+  return hasHeaderPair || hasHunk || hasAdd && hasRemove;
+}
+function splitRawDiffSections(text) {
+  const lines = text.split("\n");
+  const segments = [];
+  let markdownLines = [];
+  let inFence = false;
+  let index = 0;
+  const flushMarkdown = () => {
+    if (markdownLines.length === 0) return;
+    segments.push({ kind: "markdown", text: markdownLines.join("\n") });
+    markdownLines = [];
+  };
+  while (index < lines.length) {
+    const line = lines[index] ?? "";
+    if (/^\s*```\s*[A-Za-z0-9_+-]*\s*$/u.test(line)) {
+      inFence = !inFence;
+      markdownLines.push(line);
+      index += 1;
+      continue;
+    }
+    if (!inFence && isRawDiffStart(lines, index)) {
+      const diffLines = [];
+      let cursor = index;
+      while (cursor < lines.length) {
+        const current = lines[cursor] ?? "";
+        if (current.trim().length === 0) {
+          const next = lines[cursor + 1] ?? "";
+          if (isRawDiffLine(next)) {
+            diffLines.push(current);
+            cursor += 1;
+            continue;
+          }
+          break;
+        }
+        if (!isRawDiffLine(current)) break;
+        diffLines.push(current);
+        cursor += 1;
+      }
+      if (isRawDiffBlock(diffLines)) {
+        flushMarkdown();
+        segments.push({ kind: "diff", text: diffLines.join("\n") });
+        index = cursor;
+        continue;
+      }
+    }
+    markdownLines.push(line);
+    index += 1;
+  }
+  flushMarkdown();
+  return segments;
+}
+function __testSplitRawDiffSections(text) {
+  const normalized = stripLowValueDiagnosticNoise(text.replace(/\r/g, ""));
+  return splitRawDiffSections(normalized);
+}
+function tokenizeInline(value) {
+  const tokens = [];
+  let remaining = value;
+  while (remaining.length > 0) {
+    const match = remaining.match(INLINE_TOKEN_RE);
+    if (!match || match.index === void 0) {
+      tokens.push({ kind: "text", value: remaining });
+      break;
+    }
+    if (match.index > 0) {
+      tokens.push({ kind: "text", value: remaining.slice(0, match.index) });
+    }
+    const matched = match[0];
+    if (matched.startsWith("`")) {
+      tokens.push({ kind: "code", value: matched.slice(1, -1) });
+    } else if (matched.startsWith("**")) {
+      tokens.push({ kind: "bold", value: matched.slice(2, -2) });
+    } else if (matched.startsWith("[")) {
+      const link = matched.match(/^\[([^\]\n]+)\]\(([^\s)\n]+)\)$/u);
+      if (link) tokens.push({ kind: "link", value: link[1] ?? "", href: link[2] ?? "" });
+      else tokens.push({ kind: "text", value: matched });
+    } else {
+      tokens.push({ kind: "italic", value: matched.slice(1, -1) });
+    }
+    remaining = remaining.slice(match.index + matched.length);
+  }
+  return tokens;
+}
+function baseColor(theme, dim, tone) {
+  if (dim) return theme.dim;
+  if (tone === "error") return theme.error;
+  if (tone === "diagnostic") return theme.diagnostic;
+  return theme.assistantText;
+}
+function InlineText({
+  value,
+  theme,
+  dim,
+  tone,
+  selected
+}) {
+  const color = baseColor(theme, dim, tone);
+  const codeColor = theme.inlineCode ?? theme.dim ?? theme.muted;
+  const tokens = tokenizeInline(value);
+  return /* @__PURE__ */ jsx(
+    Text,
+    {
+      color: selected ? "white" : color,
+      backgroundColor: selected && theme.mode !== "no-color" ? "blue" : void 0,
+      dimColor: selected ? false : dim,
+      children: tokens.map((token, tokenIndex) => {
+        const key = `${tokenIndex}-${token.kind}-${token.value}`;
+        if (token.kind === "code") {
+          return /* @__PURE__ */ jsx(
+            Text,
+            {
+              color: selected ? "white" : codeColor,
+              dimColor: selected ? false : dim,
+              children: token.value
+            },
+            key
+          );
+        }
+        if (token.kind === "bold") {
+          return /* @__PURE__ */ jsx(
+            Text,
+            {
+              bold: true,
+              color: selected ? "white" : color,
+              dimColor: selected ? false : dim,
+              children: token.value
+            },
+            key
+          );
+        }
+        if (token.kind === "italic") {
+          return /* @__PURE__ */ jsx(
+            Text,
+            {
+              italic: true,
+              color: selected ? "white" : color,
+              dimColor: selected ? false : dim,
+              children: token.value
+            },
+            key
+          );
+        }
+        if (token.kind === "link") {
+          return /* @__PURE__ */ jsx(
+            Text,
+            {
+              color: selected ? "white" : theme.diagnostic ?? theme.accent,
+              underline: true,
+              children: token.value
+            },
+            key
+          );
+        }
+        return /* @__PURE__ */ jsx(Text, { children: token.value }, key);
+      })
+    }
+  );
+}
+function InlineRow({
+  value,
+  theme,
+  dim,
+  tone,
+  wrapWidth,
+  selected
+}) {
+  const rows = wrapWidth ? wrapText(value, wrapWidth) : [value];
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rows.map((row, rowIndex) => /* @__PURE__ */ jsx(
+    InlineText,
+    {
+      value: row,
+      theme,
+      dim,
+      tone,
+      selected
+    },
+    `${rowIndex}-${row}`
+  )) });
+}
+function InlineCellRangeRow({
+  value,
+  ranges,
+  theme,
+  dim,
+  tone
+}) {
+  const segments = splitLineBySelectionRanges(value, ranges);
+  return /* @__PURE__ */ jsx(Text, { children: segments.map((segment, index) => /* @__PURE__ */ jsx(
+    InlineText,
+    {
+      value: segment.text,
+      theme,
+      dim,
+      tone,
+      selected: segment.selected
+    },
+    `${index}-${segment.selected ? "selected" : "plain"}-${segment.text}`
+  )) });
+}
+function splitLineBySelectionRanges(value, ranges) {
+  const chars = Array.from(value);
+  const totalWidth = chars.reduce((width, char) => width + Math.max(1, charWidth(char)), 0);
+  const normalized = ranges.map((range) => ({
+    start: Math.max(0, Math.min(totalWidth, range.startColumn)),
+    end: Math.max(0, Math.min(totalWidth, range.endColumn))
+  })).filter((range) => range.end > range.start).sort((a, b) => a.start - b.start || a.end - b.end);
+  if (normalized.length === 0) return [{ text: value, selected: false }];
+  const merged = [];
+  for (const range of normalized) {
+    const previous = merged.at(-1);
+    if (previous && range.start <= previous.end) previous.end = Math.max(previous.end, range.end);
+    else merged.push({ ...range });
+  }
+  const segments = [];
+  let current = "";
+  let currentSelected;
+  let column = 0;
+  const pushCurrent = () => {
+    if (currentSelected === void 0 || current.length === 0) return;
+    segments.push({ text: current, selected: currentSelected });
+    current = "";
+  };
+  for (const char of chars) {
+    const width = Math.max(1, charWidth(char));
+    const selected = merged.some((range) => range.start < column + width && range.end > column);
+    if (currentSelected !== selected) {
+      pushCurrent();
+      currentSelected = selected;
+    }
+    current += char;
+    column += width;
+  }
+  pushCurrent();
+  return segments;
+}
+function stripAnsi(value) {
+  return value.replace(ANSI_REGEX, "");
+}
+function highlightedCodeLines(code, lang) {
+  if (!lang) return code.split("\n");
+  if (lang === "diff" || lang === "patch") return code.split("\n");
+  try {
+    return highlight(code, { language: lang, ignoreIllegals: true }).split("\n");
+  } catch {
+    return code.split("\n");
+  }
+}
+function CodeLine({
+  line,
+  highlightedLine,
+  lang,
+  theme,
+  dim,
+  selected,
+  ranges,
+  wrapWidth
+}) {
+  const isDiff = lang === "diff" || lang === "patch";
+  const color = isDiff && line.startsWith("+") && !line.startsWith("+++") ? theme.success ?? theme.status.pass : isDiff && line.startsWith("-") && !line.startsWith("---") ? theme.error ?? theme.status.fail : theme.diagnostic ?? theme.accent;
+  const dimLine = dim || isDiff && !line.startsWith("+") && !line.startsWith("-");
+  if (ranges && ranges.length > 0) {
+    const segments = splitLineBySelectionRanges(line.length === 0 ? " " : line, ranges);
+    return /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: segments.map((segment, index) => /* @__PURE__ */ jsx(
+      Text,
+      {
+        color: segment.selected ? "white" : color,
+        backgroundColor: segment.selected && theme.mode !== "no-color" ? "blue" : void 0,
+        dimColor: segment.selected ? false : dimLine,
+        children: segment.text
+      },
+      `${index}-${segment.selected ? "selected" : "plain"}-${segment.text}`
+    )) });
+  }
+  const rawWrapped = wrapText(line.length === 0 ? " " : line, wrapWidth);
+  const highlightedFits = highlightedLine && rawWrapped.length === 1 && displayWidth(stripAnsi(highlightedLine)) <= wrapWidth;
+  const rows = highlightedFits ? [highlightedLine] : rawWrapped;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rows.map((wrapped, index) => {
+    const padded = padDisplay(wrapped, wrapWidth);
+    return /* @__PURE__ */ jsx(
+      Text,
+      {
+        color: selected ? "white" : highlightedFits && !isDiff ? void 0 : color,
+        backgroundColor: selected && theme.mode !== "no-color" ? "blue" : void 0,
+        dimColor: selected ? false : dimLine,
+        children: padded
+      },
+      `${index}-${stripAnsi(wrapped)}`
+    );
+  }) });
+}
+function renderCodeBlock({
+  code,
+  lang,
+  theme,
+  dim,
+  wrapWidth,
+  blockKey
+}) {
+  if (lang === "diff" || lang === "patch") {
+    return /* @__PURE__ */ jsx(StructuredDiff, { code, theme, wrapWidth, dim }, blockKey);
+  }
+  const rawLines = code.split("\n");
+  const highlighted = getCachedHighlightedCodeLines(code, lang);
+  const lineCount = rawLines.length;
+  const gutterWidth = String(lineCount).length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [
+    lang ? /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: dim, children: `  ${lang}` }) : null,
+    rawLines.map((line, lineIndex) => {
+      const num = String(lineIndex + 1).padStart(gutterWidth, " ");
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: `${num} \u2502 ` }),
+        /* @__PURE__ */ jsx(
+          CodeLine,
+          {
+            line,
+            highlightedLine: highlighted[lineIndex],
+            lang,
+            theme,
+            dim,
+            wrapWidth: Math.max(8, wrapWidth - gutterWidth - 4)
+          }
+        )
+      ] }, `${blockKey}-line-${lineIndex}-${line}`);
+    })
+  ] }, blockKey);
+}
+function tokenPlainText(token) {
+  const maybeText = token;
+  return typeof maybeText.text === "string" ? maybeText.text : typeof maybeText.raw === "string" ? maybeText.raw : "";
+}
+function renderToken({
+  token,
+  theme,
+  dim,
+  tone,
+  wrapWidth,
+  keyPrefix
+}) {
+  switch (token.type) {
+    case "space":
+      return /* @__PURE__ */ jsx(Box, { height: 1 }, keyPrefix);
+    case "heading": {
+      const heading = token;
+      return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: heading.depth <= 2 ? 1 : 0, children: wrapText(`${"#".repeat(heading.depth)} ${heading.text}`, wrapWidth).map(
+        (line, index) => /* @__PURE__ */ jsx(
+          Text,
+          {
+            bold: true,
+            color: dim ? theme.dim : theme.accent ?? theme.brand,
+            dimColor: dim,
+            children: line
+          },
+          `${keyPrefix}-heading-${index}-${line}`
+        )
+      ) }, keyPrefix);
+    }
+    case "paragraph":
+    case "text":
+      return /* @__PURE__ */ jsx(
+        InlineRow,
+        {
+          value: tokenPlainText(token),
+          theme,
+          dim,
+          tone,
+          wrapWidth
+        },
+        keyPrefix
+      );
+    case "blockquote": {
+      const quote = token;
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: dim, children: "\u258C " }),
+        /* @__PURE__ */ jsx(
+          MessageMarkdown,
+          {
+            text: quote.text,
+            theme,
+            dim,
+            tone,
+            wrapWidth: wrapWidth - 2
+          }
+        )
+      ] }, keyPrefix);
+    }
+    case "list": {
+      const list = token;
+      return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: list.items.map((item, index) => {
+        const marker = list.ordered ? `${Number(list.start || 1) + index}.` : item.task ? item.checked ? "\u2611" : "\u2610" : "-";
+        return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsxs(Text, { color: dim ? theme.dim : theme.muted, dimColor: dim, children: [
+            marker,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx(
+            InlineRow,
+            {
+              value: item.text.replace(/\n+/gu, " "),
+              theme,
+              dim,
+              tone,
+              wrapWidth: Math.max(8, wrapWidth - marker.length - 1)
+            }
+          )
+        ] }, `${keyPrefix}-item-${index}`);
+      }) }, keyPrefix);
+    }
+    case "code": {
+      const code = token;
+      return renderCodeBlock({
+        code: code.text,
+        lang: code.lang,
+        theme,
+        dim,
+        wrapWidth,
+        blockKey: keyPrefix
+      });
+    }
+    case "table":
+      return renderTable(token, theme, dim, tone, wrapWidth, keyPrefix);
+    case "hr":
+      return /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: dim, children: "\u2500".repeat(Math.min(wrapWidth, 40)) }, keyPrefix);
+    default:
+      return /* @__PURE__ */ jsx(
+        InlineRow,
+        {
+          value: tokenPlainText(token),
+          theme,
+          dim,
+          tone,
+          wrapWidth
+        },
+        keyPrefix
+      );
+  }
+}
+function renderMarkdownTokens({
+  text,
+  theme,
+  dim,
+  tone,
+  wrapWidth,
+  keyPrefix
+}) {
+  const tokens = getCachedMarkdownTokens(text);
+  return tokens.map(
+    (token, index) => renderToken({
+      token,
+      theme,
+      dim,
+      tone,
+      wrapWidth,
+      keyPrefix: `${keyPrefix}-${index}-${token.type}-${token.raw.slice(0, 16)}`
+    })
+  );
+}
+function buildTableCell(text, width) {
+  const lines = wrapText(text, Math.max(4, width));
+  return { text, lines, width };
+}
+function padDisplay(value, width) {
+  const visible = displayWidth(stripAnsi(value));
+  return `${value}${" ".repeat(Math.max(0, width - visible))}`;
+}
+function tableWidths(table, wrapWidth) {
+  const columnCount = table.header.length;
+  const maxPerCol = Math.max(
+    TABLE_MIN_COLUMN_WIDTH,
+    Math.min(TABLE_MAX_COLUMN_WIDTH, Math.floor(wrapWidth * 0.45))
+  );
+  const rawWidths = Array.from({ length: columnCount }, (_, index) => {
+    const values = [
+      table.header[index]?.text ?? "",
+      ...table.rows.map((row) => row[index]?.text ?? "")
+    ];
+    return Math.min(
+      maxPerCol,
+      Math.max(TABLE_MIN_COLUMN_WIDTH, ...values.map((value) => displayWidth(value)))
+    );
+  });
+  const borderWidth = columnCount + 1;
+  const paddingWidth = columnCount * 2;
+  const available = Math.max(
+    columnCount * TABLE_MIN_COLUMN_WIDTH,
+    wrapWidth - borderWidth - paddingWidth
+  );
+  const total = rawWidths.reduce((sum, width) => sum + width, 0);
+  if (total <= available) return rawWidths;
+  const scale = available / total;
+  const proportional = rawWidths.map(
+    (w) => Math.max(TABLE_MIN_COLUMN_WIDTH, Math.floor(w * scale))
+  );
+  if (proportional.some((w) => w < TABLE_MIN_ACCEPTABLE_COLUMN)) {
+    return rawWidths;
+  }
+  return proportional;
+}
+function renderTable(table, theme, dim, tone, wrapWidth, keyPrefix) {
+  const columnCount = table.header.length;
+  if (columnCount === 0) return null;
+  const widths = tableWidths(table, wrapWidth);
+  const tableWidth = widths.reduce((sum, width) => sum + width + 2, 1);
+  if (wrapWidth < TABLE_VERTICAL_FALLBACK_WIDTH || tableWidth > wrapWidth) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: table.rows.map((row, rowIndex) => /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: row.map((cell, cellIndex) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsxs(Text, { color: theme.muted, dimColor: dim, children: [
+        table.header[cellIndex]?.text ?? `#${cellIndex + 1}`,
+        ":",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(
+        InlineRow,
+        {
+          value: cell.text,
+          theme,
+          dim,
+          tone,
+          wrapWidth: Math.max(
+            8,
+            wrapWidth - displayWidth(table.header[cellIndex]?.text ?? `#${cellIndex + 1}`) - 2
+          )
+        }
+      )
+    ] }, `${keyPrefix}-vertical-${rowIndex}-${cellIndex}`)) }, `${keyPrefix}-vertical-${rowIndex}`)) }, keyPrefix);
+  }
+  const borderColor = theme.dim ?? theme.muted;
+  const border = (left, mid, right) => `${left}${widths.map((width) => "\u2500".repeat(width + 2)).join(mid)}${right}`;
+  const renderRow = (cells, rowKey, boldHeader = false) => {
+    const height = Math.max(...cells.map((cell) => cell.lines.length));
+    return Array.from({ length: height }, (_, lineIndex) => /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: borderColor, dimColor: dim, children: "\u2502" }),
+      cells.map((cell, cellIndex) => /* @__PURE__ */ jsxs(Text, { children: [
+        " ",
+        /* @__PURE__ */ jsx(Text, { bold: boldHeader, color: boldHeader && !dim ? theme.accent : void 0, children: padDisplay(cell.lines[lineIndex] ?? "", cell.width) }),
+        " ",
+        /* @__PURE__ */ jsx(Text, { color: borderColor, dimColor: dim, children: "\u2502" })
+      ] }, `${rowKey}-${lineIndex}-${cellIndex}`))
+    ] }, `${rowKey}-${lineIndex}`));
+  };
+  const header = table.header.map((cell, index) => buildTableCell(cell.text, widths[index] ?? 4));
+  const rows = table.rows.map(
+    (row) => row.map((cell, index) => buildTableCell(cell.text, widths[index] ?? 4))
+  );
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: borderColor, dimColor: dim, children: border("\u250C", "\u252C", "\u2510") }),
+    renderRow(header, `${keyPrefix}-header`, true),
+    /* @__PURE__ */ jsx(Text, { color: borderColor, dimColor: dim, children: border("\u251C", "\u253C", "\u2524") }),
+    rows.flatMap((row, index) => [
+      ...renderRow(row, `${keyPrefix}-row-${index}`),
+      ...index < rows.length - 1 ? [
+        /* @__PURE__ */ jsx(Text, { color: borderColor, dimColor: dim, children: border("\u251C", "\u253C", "\u2524") }, `${keyPrefix}-sep-${index}`)
+      ] : []
+    ]),
+    /* @__PURE__ */ jsx(Text, { color: borderColor, dimColor: dim, children: border("\u2514", "\u2534", "\u2518") })
+  ] }, keyPrefix);
+}
+function MessageMarkdown({
+  text,
+  theme,
+  dim = false,
+  tone = "default",
+  wrapWidth,
+  selectionLineIndexes,
+  selectionLineRanges,
+  isStreaming
+}) {
+  if (!text || text.length === 0) return null;
+  if ((selectionLineIndexes?.length ?? 0) > 0 || (selectionLineRanges?.length ?? 0) > 0) {
+    return renderSelectablePlainMarkdown({
+      text,
+      theme,
+      dim,
+      tone,
+      wrapWidth,
+      selectionLineIndexes,
+      selectionLineRanges
+    });
+  }
+  if (isStreaming) {
+    const lines = text.replace(/\r/g, "").split("\n");
+    const color = baseColor(theme, dim, tone);
+    const effectiveWrapWidth2 = wrapWidth ?? 80;
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.flatMap(
+      (line, i) => wrapText(line, effectiveWrapWidth2).map((wrapped, wrappedIndex) => /* @__PURE__ */ jsx(Text, { color, dimColor: dim, children: wrapped }, `s${i}-${wrappedIndex}-${wrapped}`))
+    ) });
+  }
+  const effectiveWrapWidth = wrapWidth ?? 80;
+  const normalized = stripLowValueDiagnosticNoise(text.replace(/\r/g, ""));
+  const segments = splitRawDiffSections(normalized);
+  if (segments.some((segment) => segment.kind === "diff")) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: segments.map(
+      (segment, index) => segment.kind === "diff" ? /* @__PURE__ */ jsx(
+        StructuredDiff,
+        {
+          code: segment.text,
+          theme,
+          wrapWidth: effectiveWrapWidth,
+          dim
+        },
+        `raw-diff-${index}`
+      ) : /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: renderMarkdownTokens({
+        text: segment.text,
+        theme,
+        dim,
+        tone,
+        wrapWidth: effectiveWrapWidth,
+        keyPrefix: `markdown-${index}`
+      }) }, `markdown-${index}`)
+    ) });
+  }
+  const tokens = getCachedMarkdownTokens(normalized);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: tokens.map(
+    (token, index) => renderToken({
+      token,
+      theme,
+      dim,
+      tone,
+      wrapWidth: effectiveWrapWidth,
+      keyPrefix: `${index}-${token.type}-${token.raw.slice(0, 16)}`
+    })
+  ) });
+}
+function renderSelectablePlainMarkdown({
+  text,
+  theme,
+  dim,
+  tone,
+  wrapWidth,
+  selectionLineIndexes,
+  selectionLineRanges
+}) {
+  const lines = text.replace(/\r/g, "").split("\n");
+  const selectedLines = new Set(selectionLineIndexes ?? []);
+  const selectedRangesByLine = /* @__PURE__ */ new Map();
+  for (const range of selectionLineRanges ?? []) {
+    const existing = selectedRangesByLine.get(range.lineIndex) ?? [];
+    existing.push(range);
+    selectedRangesByLine.set(range.lineIndex, existing);
+  }
+  const effectiveWrapWidth = wrapWidth ?? 80;
+  let inCode = false;
+  let codeLang;
+  let codeLineNum = 0;
+  const rendered = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const raw = lines[lineIndex] ?? "";
+    const fence = raw.match(/^\s*```\s*([A-Za-z0-9_+-]*)\s*$/u);
+    if (fence) {
+      inCode = !inCode;
+      codeLang = inCode ? fence[1] || void 0 : void 0;
+      codeLineNum = 0;
+      continue;
+    }
+    const ranges = selectedRangesByLine.get(lineIndex) ?? [];
+    if (inCode) {
+      codeLineNum++;
+      const gutter = String(codeLineNum).padStart(2, " ");
+      rendered.push(
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: `${gutter} \u2502 ` }),
+          /* @__PURE__ */ jsx(
+            CodeLine,
+            {
+              line: raw,
+              lang: codeLang,
+              theme,
+              dim,
+              selected: selectedLines.has(lineIndex),
+              ranges,
+              wrapWidth: Math.max(8, effectiveWrapWidth - 5)
+            }
+          )
+        ] }, `code-line-${lineIndex}-${raw}`)
+      );
+      continue;
+    }
+    if (raw.trim().length === 0) {
+      rendered.push(/* @__PURE__ */ jsx(Box, { height: 1 }, `blank-${lineIndex}`));
+      continue;
+    }
+    if (ranges.length > 0) {
+      rendered.push(
+        /* @__PURE__ */ jsx(
+          InlineCellRangeRow,
+          {
+            value: raw,
+            ranges,
+            theme,
+            dim,
+            tone
+          },
+          `range-${lineIndex}`
+        )
+      );
+      continue;
+    }
+    rendered.push(
+      /* @__PURE__ */ jsx(
+        InlineRow,
+        {
+          value: raw,
+          theme,
+          dim,
+          tone,
+          wrapWidth,
+          selected: selectedLines.has(lineIndex)
+        },
+        `line-${lineIndex}-${raw}`
+      )
+    );
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rendered });
+}
+var MemoMessageMarkdown = memo(MessageMarkdown);
+function splitStreamingMarkdownForRender(text, state) {
+  const normalized = text.replace(/\r/g, "");
+  if (!normalized.startsWith(state.stablePrefix)) {
+    state.stablePrefix = "";
+  }
+  const boundary = state.stablePrefix.length;
+  const suffixInput = normalized.slice(boundary);
+  const advance = findStablePrefixAdvance(suffixInput);
+  if (advance > 0) {
+    state.stablePrefix = normalized.slice(0, boundary + advance);
+  }
+  return {
+    stablePrefix: state.stablePrefix,
+    unstableSuffix: normalized.slice(state.stablePrefix.length),
+    parsedSuffixInput: suffixInput
+  };
+}
+function findStablePrefixAdvance(text) {
+  let offset = 0;
+  let boundary = 0;
+  let inCode = false;
+  for (const match of text.matchAll(/[^\n]*(?:\n|$)/gu)) {
+    const segment = match[0];
+    if (!segment) break;
+    if (!segment.endsWith("\n")) break;
+    const line = segment.slice(0, -1);
+    const fence = /^\s*```\s*[A-Za-z0-9_+-]*\s*$/u.test(line);
+    if (fence) {
+      inCode = !inCode;
+      offset += segment.length;
+      if (!inCode) boundary = offset;
+      continue;
+    }
+    offset += segment.length;
+    if (!inCode && line.trim().length === 0) boundary = offset;
+  }
+  if (!inCode && text.endsWith("\n") && hasBalancedInlineMarkdown(text)) return text.length;
+  return boundary;
+}
+function hasBalancedInlineMarkdown(text) {
+  let inInlineCode = false;
+  let boldOpen = false;
+  let italicOpen = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (char === "`") {
+      inInlineCode = !inInlineCode;
+      continue;
+    }
+    if (!inInlineCode && char === "*" && text[index + 1] === "*") {
+      boldOpen = !boldOpen;
+      index += 1;
+      continue;
+    }
+    if (!inInlineCode && char === "*") {
+      italicOpen = !italicOpen;
+    }
+  }
+  return !inInlineCode && !boldOpen && !italicOpen;
+}
+function StreamingMarkdown({
+  text,
+  theme,
+  dim = false,
+  tone = "default",
+  wrapWidth
+}) {
+  const stateRef = useRef({ stablePrefix: "" });
+  const { stablePrefix, unstableSuffix } = splitStreamingMarkdownForRender(text, stateRef.current);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    stablePrefix ? /* @__PURE__ */ jsx(
+      MemoMessageMarkdown,
+      {
+        text: stablePrefix,
+        theme,
+        dim,
+        tone,
+        wrapWidth
+      }
+    ) : null,
+    unstableSuffix ? /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(
+        MessageMarkdown,
+        {
+          text: unstableSuffix,
+          theme,
+          dim,
+          tone,
+          wrapWidth,
+          isStreaming: true
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { color: theme.accent, children: "\u258C" })
+    ] }) : /* @__PURE__ */ jsx(Text, { color: theme.accent, children: "\u258C" })
+  ] });
+}
+
+export {
+  useInMessageResponse,
+  MessageResponseProvider,
+  __testSplitRawDiffSections,
+  MessageMarkdown,
+  splitStreamingMarkdownForRender,
+  StreamingMarkdown
+};