@ai-matrx/rich-content 0.2.3 → 0.2.6

package/dist/display/blocks/table/TableRenderPathDiagnostic.d.ts

@@ -0,0 +1,21 @@
+export interface TableRenderDiagnosticContext {
+    /** Block type that routed here (usually "text"). */
+    blockType: string;
+    /** Where in the pipeline this markdown table was rendered. */
+    renderPath: "BasicMarkdownContent";
+    conversationId?: string;
+    messageId?: string;
+    requestId?: string;
+    surfaceKey?: string;
+    /** First ~120 chars of the hosting block for identification. */
+    contentPreview?: string;
+}
+interface TableRenderPathDiagnosticProps {
+    context: TableRenderDiagnosticContext;
+}
+/**
+ * Admin-only warning shown under tables that rendered through the markdown
+ * fallback (react-markdown GFM) instead of StreamingTableRenderer / TableArtifact.
+ */
+export declare function TableRenderPathDiagnostic({ context, }: TableRenderPathDiagnosticProps): import("react").JSX.Element | null;
+export {};

package/dist/display/blocks/table/TableRenderPathDiagnostic.js

@@ -0,0 +1,79 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AlertTriangle } from "lucide-react";
+import { EntityRef } from "../../../host/app-bindings.js";
+import { useIsAdminDebugger } from "../../../host/app-bindings.js";
+function TableRenderPathDiagnostic({
+  context
+}) {
+  const isAdmin = Boolean(useIsAdminDebugger());
+  if (!isAdmin) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "my-2 rounded-md border border-amber-500/60 bg-amber-50/90 px-3 py-2 text-xs text-amber-950 dark:bg-amber-950/40 dark:text-amber-100", children: [
+    /* @__PURE__ */ jsxs("div", { className: "mb-1 flex items-center gap-1.5 font-semibold", children: [
+      /* @__PURE__ */ jsx(AlertTriangle, { className: "h-3.5 w-3.5 shrink-0" }),
+      "Table render path diagnostic (admin)"
+    ] }),
+    /* @__PURE__ */ jsxs("p", { className: "mb-2 leading-relaxed opacity-90", children: [
+      "This table was rendered by",
+      " ",
+      /* @__PURE__ */ jsx("code", { className: "rounded bg-amber-200/60 px-1 dark:bg-amber-900/60", children: context.renderPath }),
+      " ",
+      "(plain GFM HTML), not",
+      " ",
+      /* @__PURE__ */ jsx("code", { className: "rounded bg-amber-200/60 px-1 dark:bg-amber-900/60", children: "StreamingTableRenderer" }),
+      ". The block splitter did not promote it to",
+      " ",
+      /* @__PURE__ */ jsx("code", { className: "rounded bg-amber-200/60 px-1 dark:bg-amber-900/60", children: 'type: "table"' }),
+      " ",
+      "before render."
+    ] }),
+    /* @__PURE__ */ jsxs("dl", { className: "grid gap-1 font-mono text-[11px] leading-relaxed opacity-80", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "inline font-semibold", children: "host block type: " }),
+        /* @__PURE__ */ jsx("dd", { className: "inline", children: context.blockType })
+      ] }),
+      context.surfaceKey ? /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "inline font-semibold", children: "surfaceKey: " }),
+        /* @__PURE__ */ jsx("dd", { className: "inline break-all", children: context.surfaceKey })
+      ] }) : null,
+      context.conversationId ? /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "inline font-semibold", children: "conversationId: " }),
+        /* @__PURE__ */ jsx("dd", { className: "inline", children: /* @__PURE__ */ jsx(
+          EntityRef,
+          {
+            token: "conversation",
+            id: context.conversationId,
+            name: context.conversationId,
+            showIcon: false,
+            openInNewTab: true,
+            wrap: true,
+            className: "inline-flex"
+          }
+        ) })
+      ] }) : null,
+      context.messageId ? /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "inline font-semibold", children: "messageId: " }),
+        /* @__PURE__ */ jsx("dd", { className: "inline break-all", children: context.messageId })
+      ] }) : null,
+      context.requestId ? /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "inline font-semibold", children: "requestId: " }),
+        /* @__PURE__ */ jsx("dd", { className: "inline break-all", children: context.requestId })
+      ] }) : null,
+      context.contentPreview ? /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("dt", { className: "inline font-semibold", children: "block preview: " }),
+        /* @__PURE__ */ jsx("dd", { className: "inline break-all", children: context.contentPreview })
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsxs("p", { className: "mt-2 leading-relaxed opacity-75", children: [
+      "Likely causes: Redux client ",
+      /* @__PURE__ */ jsx("code", { children: "text" }),
+      " block skipped re-split (processedBlocks path), DB text fragment without header+separator in the same part, or malformed table markdown (rows must start with",
+      " ",
+      /* @__PURE__ */ jsx("code", { children: "|" }),
+      ")."
+    ] })
+  ] });
+}
+export {
+  TableRenderPathDiagnostic
+};

package/dist/display/blocks/thinking-reasoning/ConsolidatedReasoningVisualization.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+/**
+ * Adapter — multi-step reasoning collapses into the single unified
+ * {@link ThinkingTrace}. The steps are joined into one trace; expanding shows
+ * them in order.
+ */
+interface ConsolidatedReasoningVisualizationProps {
+    /** Raw reasoning text blocks (the content from each `<reasoning>` block). */
+    reasoningTexts: string[];
+    showReasoning?: boolean;
+    isStreaming?: boolean;
+}
+declare const ConsolidatedReasoningVisualization: React.FC<ConsolidatedReasoningVisualizationProps>;
+export default ConsolidatedReasoningVisualization;

package/dist/display/blocks/thinking-reasoning/ConsolidatedReasoningVisualization.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import ThinkingTrace from "./ThinkingTrace.js";
+const ConsolidatedReasoningVisualization = ({ reasoningTexts, showReasoning = true, isStreaming = false }) => /* @__PURE__ */ jsx(
+  ThinkingTrace,
+  {
+    texts: reasoningTexts,
+    showThinking: showReasoning,
+    isStreaming
+  }
+);
+var ConsolidatedReasoningVisualization_default = ConsolidatedReasoningVisualization;
+export {
+  ConsolidatedReasoningVisualization_default as default
+};

package/dist/display/blocks/thinking-reasoning/ReasoningVisualization.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+/**
+ * Adapter — the canonical renderer is the unified, text-based
+ * {@link ThinkingTrace}. Kept so every caller (BlockRenderer's `thinking` /
+ * `reasoning` cases, the legacy chat stream display, demos) renders identically.
+ */
+interface ReasoningVisualizationProps {
+    reasoningText: string;
+    showReasoning?: boolean;
+    isStreaming?: boolean;
+}
+declare const ReasoningVisualization: React.FC<ReasoningVisualizationProps>;
+export default ReasoningVisualization;

package/dist/display/blocks/thinking-reasoning/ReasoningVisualization.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import ThinkingTrace from "./ThinkingTrace.js";
+const ReasoningVisualization = ({
+  reasoningText,
+  showReasoning = true,
+  isStreaming = false
+}) => /* @__PURE__ */ jsx(
+  ThinkingTrace,
+  {
+    text: reasoningText,
+    showThinking: showReasoning,
+    isStreaming
+  }
+);
+var ReasoningVisualization_default = ReasoningVisualization;
+export {
+  ReasoningVisualization_default as default
+};

package/dist/display/blocks/thinking-reasoning/ThinkingTrace.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+export interface ThinkingTraceProps {
+    /** A single thinking/reasoning text block. */
+    text?: string;
+    /** Multiple reasoning steps (consolidated) — joined into one trace. */
+    texts?: string[];
+    /** Hide entirely (per-surface `hideReasoning`). */
+    showThinking?: boolean;
+    /** True while tokens are still arriving — shows the thought "coming in". */
+    isStreaming?: boolean;
+}
+/**
+ * ThinkingTrace — the single, unified renderer for model thinking / reasoning.
+ *
+ * One primitive for EVERY source: live stream, static markdown, and DB-loaded
+ * turns all render through this. There is no per-source variant.
+ *
+ * It reads like a line of the transcript, not a component:
+ *   - collapsed by default — a quiet, muted affordance. No box, no border fill,
+ *     no gradient, no background. It takes up about one line.
+ *   - while streaming — the latest line of thought streams in on that one line,
+ *     so you can watch it think without it being in your face.
+ *   - click to expand — the full reasoning text, lightly indented.
+ *
+ * The legacy boxes (`ThinkingVisualization`, `ReasoningVisualization`,
+ * `ConsolidatedReasoningVisualization`) are now thin adapters over this, so
+ * the look is identical everywhere it appears.
+ */
+declare const ThinkingTrace: React.FC<ThinkingTraceProps>;
+export default ThinkingTrace;

package/dist/display/blocks/thinking-reasoning/ThinkingTrace.js

@@ -0,0 +1,75 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { ChevronRight } from "lucide-react";
+import { cn } from "@ai-matrx/design-system";
+import { ShimmerText } from "../../../utils/lifted/ShimmerText.js";
+import { ThinkingTraceMarkdown } from "./ThinkingTraceMarkdown.js";
+const ThinkingTrace = ({
+  text,
+  texts,
+  showThinking = true,
+  isStreaming = false
+}) => {
+  const [expanded, setExpanded] = useState(false);
+  const bodyRef = useRef(null);
+  const stripReasoningTags = (s) => s.replace(/<\/?(?:thinking|think|reasoning|reason)>/gi, "");
+  const fullText = stripReasoningTags(
+    texts && texts.length > 0 ? texts.filter((t) => t?.trim()).join("\n\n") : text ?? ""
+  ).trim();
+  useEffect(() => {
+    if (expanded && isStreaming && bodyRef.current) {
+      bodyRef.current.scrollTop = bodyRef.current.scrollHeight;
+    }
+  }, [fullText, expanded, isStreaming]);
+  if (!showThinking || !fullText) return null;
+  const tail = fullText.split("\n").filter((l) => l.trim()).pop() ?? "";
+  const collapsedLabel = isStreaming ? tail || "Thinking\u2026" : "Thought process";
+  return /* @__PURE__ */ jsxs("div", { className: "my-1.5 text-xs", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => setExpanded((v) => !v),
+        "aria-expanded": expanded,
+        className: "flex w-full items-center gap-1.5 text-left text-muted-foreground transition-colors hover:text-foreground",
+        children: [
+          /* @__PURE__ */ jsx(
+            ChevronRight,
+            {
+              className: cn(
+                "h-3 w-3 shrink-0 transition-transform",
+                expanded && "rotate-90"
+              )
+            }
+          ),
+          isStreaming && !expanded && /* @__PURE__ */ jsx("span", { className: "h-1.5 w-1.5 shrink-0 animate-pulse rounded-full bg-muted-foreground/50" }),
+          isStreaming && !expanded ? tail ? /* @__PURE__ */ jsx(
+            ThinkingTraceMarkdown,
+            {
+              content: tail,
+              variant: "inline",
+              className: "min-w-0 flex-1 text-xs"
+            }
+          ) : (
+            // Gradient sweep when tokens haven't arrived yet — same shimmer as
+            // "Processing…" / "Planning…".
+            /* @__PURE__ */ jsx(ShimmerText, { text: "Thinking\u2026", className: "truncate text-xs" })
+          ) : /* @__PURE__ */ jsx("span", { className: "truncate", children: expanded ? "Thought process" : collapsedLabel })
+        ]
+      }
+    ),
+    expanded && /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: bodyRef,
+        className: "mt-1 ml-1 max-h-[400px] overflow-y-auto border-l border-border/60 pl-3 leading-relaxed",
+        children: /* @__PURE__ */ jsx(ThinkingTraceMarkdown, { content: fullText, variant: "body" })
+      }
+    )
+  ] });
+};
+var ThinkingTrace_default = ThinkingTrace;
+export {
+  ThinkingTrace_default as default
+};

package/dist/display/blocks/thinking-reasoning/ThinkingTraceMarkdown.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+type ThinkingTraceMarkdownVariant = "inline" | "body";
+interface ThinkingTraceMarkdownProps {
+    content: string;
+    variant?: ThinkingTraceMarkdownVariant;
+    className?: string;
+}
+/**
+ * Compact markdown renderer for thinking / reasoning traces.
+ * `inline` keeps the collapsed one-line tail readable; `body` is for expand.
+ */
+export declare function ThinkingTraceMarkdown({ content, variant, className, }: ThinkingTraceMarkdownProps): React.JSX.Element | null;
+export {};

package/dist/display/blocks/thinking-reasoning/ThinkingTraceMarkdown.js

@@ -0,0 +1,48 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import MarkdownCore from "../../../markdown-core/MarkdownCore.js";
+import { cn } from "@ai-matrx/design-system";
+import { NestedRichContent } from "../../../levels/standard/NestedRichContent.js";
+const inlineComponents = {
+  p: ({ children }) => /* @__PURE__ */ jsx("span", { className: "inline", children }),
+  strong: ({ children }) => /* @__PURE__ */ jsx("strong", { className: "font-semibold text-foreground/85", children }),
+  em: ({ children }) => /* @__PURE__ */ jsx("em", { className: "italic", children }),
+  ul: ({ children }) => /* @__PURE__ */ jsx("span", { className: "inline", children }),
+  ol: ({ children }) => /* @__PURE__ */ jsx("span", { className: "inline", children }),
+  li: ({ children }) => /* @__PURE__ */ jsx("span", { className: "inline [&:not(:last-child)]:mr-1", children }),
+  blockquote: ({ children }) => /* @__PURE__ */ jsx("span", { className: "inline", children }),
+  code: ({ children }) => /* @__PURE__ */ jsx("code", { className: "rounded bg-muted/60 px-0.5 font-mono text-[0.9em]", children }),
+  a: ({ children, href }) => /* @__PURE__ */ jsx(
+    "a",
+    {
+      href,
+      className: "text-primary underline underline-offset-2",
+      target: "_blank",
+      rel: "noopener noreferrer",
+      children
+    }
+  )
+};
+function ThinkingTraceMarkdown({
+  content,
+  variant = "body",
+  className
+}) {
+  if (!content.trim()) return null;
+  if (variant === "body") {
+    return /* @__PURE__ */ jsx("div", { className: cn("min-w-0 text-muted-foreground", className), children: /* @__PURE__ */ jsx(NestedRichContent, { source: content }) });
+  }
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "min-w-0 text-muted-foreground truncate [&_*]:inline",
+        className
+      ),
+      children: /* @__PURE__ */ jsx(MarkdownCore, { preset: "gfm-breaks", components: inlineComponents, children: content })
+    }
+  );
+}
+export {
+  ThinkingTraceMarkdown
+};

package/dist/display/blocks/thinking-reasoning/ThinkingVisualization.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+/**
+ * Adapter — preserved for existing callers (legacy chat stream display, demos).
+ * The real rendering is the unified, text-based {@link ThinkingTrace}.
+ */
+interface ThinkingVisualizationProps {
+    thinkingText?: string;
+    showThinking?: boolean;
+    isStreaming?: boolean;
+}
+declare const ThinkingVisualization: React.FC<ThinkingVisualizationProps>;
+export default ThinkingVisualization;

package/dist/display/blocks/thinking-reasoning/ThinkingVisualization.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import ThinkingTrace from "./ThinkingTrace.js";
+const ThinkingVisualization = ({
+  thinkingText,
+  showThinking = true,
+  isStreaming = false
+}) => /* @__PURE__ */ jsx(
+  ThinkingTrace,
+  {
+    text: thinkingText,
+    showThinking,
+    isStreaming
+  }
+);
+var ThinkingVisualization_default = ThinkingVisualization;
+export {
+  ThinkingVisualization_default as default
+};

package/dist/display/blocks/toml/TomlBlock.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface TomlBlockProps {
+    content: string;
+    className?: string;
+}
+declare const TomlBlock: React.FC<TomlBlockProps>;
+export default TomlBlock;

package/dist/display/blocks/toml/TomlBlock.js

@@ -0,0 +1,167 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useClipboard } from "@ai-matrx/kit/clipboard";
+import { toast } from "../../../host/toast.js";
+import { useState } from "react";
+import { cn } from "@ai-matrx/design-system";
+import { Copy, Check, ChevronRight, ChevronDown } from "lucide-react";
+import { Button } from "@ai-matrx/design-system/controls";
+function parseTomlLines(content) {
+  return content.split("\n").map((raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      return { type: "blank", indent: 0, raw };
+    }
+    if (trimmed.startsWith("#")) {
+      return { type: "comment", indent: 0, raw };
+    }
+    const arraySection = trimmed.match(/^\[\[(.+)\]\]$/);
+    if (arraySection) {
+      return {
+        type: "array-section",
+        indent: 0,
+        section: arraySection[1],
+        raw
+      };
+    }
+    const section = trimmed.match(/^\[([^\]]+)\]$/);
+    if (section) {
+      return { type: "section", indent: 0, section: section[1], raw };
+    }
+    const kvMatch = trimmed.match(/^([^=]+?)\s*=\s*(.+)$/);
+    if (kvMatch) {
+      return {
+        type: "key-value",
+        indent: 0,
+        key: kvMatch[1].trim(),
+        value: kvMatch[2].trim(),
+        raw
+      };
+    }
+    return { type: "key-value", indent: 0, value: trimmed, raw };
+  });
+}
+function renderTomlValue(value) {
+  if (value === "true" || value === "false") {
+    return /* @__PURE__ */ jsx("span", { className: "text-orange-600 dark:text-orange-400 font-medium", children: value });
+  }
+  if (/^-?\d+(\.\d+)?$/.test(value)) {
+    return /* @__PURE__ */ jsx("span", { className: "text-purple-600 dark:text-purple-400", children: value });
+  }
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return /* @__PURE__ */ jsx("span", { className: "text-green-600 dark:text-green-400", children: value });
+  }
+  if (value.startsWith('"""') || value.startsWith("'''")) {
+    return /* @__PURE__ */ jsx("span", { className: "text-green-600 dark:text-green-400", children: value });
+  }
+  if (value.startsWith("[")) {
+    return /* @__PURE__ */ jsx("span", { className: "text-green-600 dark:text-green-400", children: value });
+  }
+  if (value.startsWith("{")) {
+    return /* @__PURE__ */ jsx("span", { className: "text-blue-600 dark:text-blue-400", children: value });
+  }
+  if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+    return /* @__PURE__ */ jsx("span", { className: "text-cyan-600 dark:text-cyan-400", children: value });
+  }
+  return /* @__PURE__ */ jsx("span", { className: "text-green-600 dark:text-green-400", children: value });
+}
+const TomlBlock = ({ content, className }) => {
+  const { copyText } = useClipboard({
+    notify: (message, kind) => kind === "error" ? toast.error(message) : toast.success(message)
+  });
+  const [copied, setCopied] = useState(false);
+  const [collapsedSections, setCollapsedSections] = useState(
+    /* @__PURE__ */ new Set()
+  );
+  const lines = parseTomlLines(content);
+  const handleCopy = async () => {
+    await copyText(content);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2e3);
+  };
+  const toggleSection = (idx) => {
+    setCollapsedSections((prev) => {
+      const next = new Set(prev);
+      if (next.has(idx)) next.delete(idx);
+      else next.add(idx);
+      return next;
+    });
+  };
+  const getSectionEnd = (sectionIdx) => {
+    let end = sectionIdx + 1;
+    while (end < lines.length) {
+      const line = lines[end];
+      if (line.type === "section" || line.type === "array-section") break;
+      end++;
+    }
+    return end;
+  };
+  const hiddenLines = /* @__PURE__ */ new Set();
+  for (const idx of collapsedSections) {
+    const end = getSectionEnd(idx);
+    for (let j = idx + 1; j < end; j++) hiddenLines.add(j);
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "my-3 rounded-lg border border-border bg-card overflow-hidden",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-3 py-1.5 border-b border-border/50 bg-muted/30", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-xs font-mono font-semibold text-violet-600 dark:text-violet-400", children: "TOML" }),
+          /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: copied ? /* @__PURE__ */ jsx(Check, {}) : /* @__PURE__ */ jsx(Copy, {}), glyphTone: copied ? "success" : void 0, onClick: handleCopy, "aria-label": "Copy" })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "px-3 py-2 font-mono text-sm leading-relaxed overflow-x-auto", children: lines.map((line, idx) => {
+          if (hiddenLines.has(idx)) return null;
+          if (line.type === "blank") {
+            return /* @__PURE__ */ jsx("div", { className: "h-3" }, idx);
+          }
+          if (line.type === "comment") {
+            return /* @__PURE__ */ jsx("div", { className: "text-muted-foreground italic", children: line.raw.trim() }, idx);
+          }
+          if (line.type === "section" || line.type === "array-section") {
+            const isCollapsed = collapsedSections.has(idx);
+            const bracket = line.type === "array-section" ? "[[" : "[";
+            const closeBracket = line.type === "array-section" ? "]]" : "]";
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: "flex items-center group/section hover:bg-muted/30 rounded-sm -mx-1 px-1 mt-2 first:mt-0",
+                children: [
+                  /* @__PURE__ */ jsx(Button, { variant: "quiet", icon: isCollapsed ? /* @__PURE__ */ jsx(ChevronRight, {}) : /* @__PURE__ */ jsx(ChevronDown, {}), onClick: () => toggleSection(idx), "aria-label": isCollapsed ? "Expand" : "Collapse", "aria-expanded": !isCollapsed, className: "mr-1" }),
+                  /* @__PURE__ */ jsxs("span", { children: [
+                    /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: bracket }),
+                    /* @__PURE__ */ jsx("span", { className: "text-blue-600 dark:text-blue-400 font-semibold", children: line.section }),
+                    /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: closeBracket })
+                  ] }),
+                  isCollapsed && /* @__PURE__ */ jsx("span", { className: "ml-2 text-xs text-muted-foreground bg-muted px-1.5 py-0.5 rounded", children: "..." })
+                ]
+              },
+              idx
+            );
+          }
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: "hover:bg-muted/30 rounded-sm -mx-1 px-1 pl-5",
+              children: [
+                line.key && /* @__PURE__ */ jsxs(Fragment, { children: [
+                  /* @__PURE__ */ jsx("code", { className: "text-amber-600 dark:text-amber-400", children: line.key }),
+                  /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: " = " })
+                ] }),
+                line.value !== void 0 && renderTomlValue(line.value)
+              ]
+            },
+            idx
+          );
+        }) })
+      ]
+    }
+  );
+};
+var TomlBlock_default = TomlBlock;
+export {
+  TomlBlock_default as default
+};

package/dist/display/blocks/tree/TreeBlock.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface TreeBlockProps {
+    content: string;
+    className?: string;
+}
+declare const TreeBlock: React.FC<TreeBlockProps>;
+export default TreeBlock;