llm-message-react 0.1.0

package/dist/index.js

@@ -0,0 +1,703 @@
+export { createShikiHighlighter } from './chunk-S3LNINQ5.js';
+import { clsx } from 'clsx';
+import { useMemo, useState, useRef, useEffect } from 'react';
+import ReactMarkdown from 'react-markdown';
+import rehypeKatex from 'rehype-katex';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import katex from 'katex';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+function completePartialTokens(text, options) {
+  if (!text) return text;
+  const showUnfinishedLatexBlocks = options?.showUnfinishedLatexBlocks ?? true;
+  if (hasUnclosedCodeFence(text)) {
+    return text;
+  }
+  const protectedSpans = [];
+  const protect = (value) => `\0llmph${protectedSpans.push(value) - 1}\0`;
+  let working = text.replace(/```[\s\S]*?```/g, (match) => protect(match));
+  working = working.replace(/``[\s\S]*?``/g, (match) => protect(match));
+  working = working.replace(/`[^`\n]+`/g, (match) => protect(match));
+  const lastBacktick = working.lastIndexOf("`");
+  if (lastBacktick !== -1) {
+    const newline = working.indexOf("\n", lastBacktick);
+    const end = newline === -1 ? working.length : newline;
+    const span = working.slice(lastBacktick, end);
+    working = working.slice(0, lastBacktick) + protect(`${span}\``) + working.slice(end);
+  }
+  working = repairIncompleteMath(working, showUnfinishedLatexBlocks);
+  working = hideIncompleteLink(working);
+  working = completePartialTable(working);
+  working = hideDanglingListMarker(working);
+  working = closeUnbalancedEmphasis(working);
+  return working.replace(
+    /\u0000llmph(\d+)\u0000/g,
+    (_match, index) => protectedSpans[Number(index)] ?? ""
+  );
+}
+function completePartialTable(text) {
+  const lines = text.split("\n");
+  if (lines.length < 2) return text;
+  const last = lines[lines.length - 1];
+  if (!/-/.test(last) || !/^[\s|:-]*$/.test(last)) return text;
+  const header = lines[lines.length - 2];
+  if (!header.includes("|")) return text;
+  for (let i = lines.length - 2; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.includes("|")) break;
+    if (/-/.test(line) && /^[\s|:-]*$/.test(line)) return text;
+  }
+  const columns = countTableColumns(header);
+  lines[lines.length - 1] = buildDelimiterRow(last, columns);
+  return lines.join("\n");
+}
+function countTableColumns(row) {
+  let inner = row.trim();
+  if (inner.startsWith("|")) inner = inner.slice(1);
+  if (inner.endsWith("|")) inner = inner.slice(0, -1);
+  return inner.split("|").length;
+}
+function buildDelimiterRow(fragment, columns) {
+  let inner = fragment.trim();
+  if (inner.startsWith("|")) inner = inner.slice(1);
+  if (inner.endsWith("|")) inner = inner.slice(0, -1);
+  const existing = inner.split("|").map((cell) => cell.trim());
+  const cells = Array.from({ length: columns }, (_unused, index) => {
+    const spec = existing[index] ?? "";
+    const left = spec.startsWith(":");
+    const right = spec.endsWith(":");
+    if (left && right) return ":---:";
+    if (right) return "---:";
+    if (left) return ":---";
+    return "---";
+  });
+  return `| ${cells.join(" | ")} |`;
+}
+function hideDanglingListMarker(text) {
+  const match = text.match(/\n[ \t]{0,3}-+[ \t]*$/);
+  if (match?.index == null) return text;
+  const before = text.slice(0, match.index);
+  const prevLine = before.slice(before.lastIndexOf("\n") + 1);
+  if (prevLine.trim() === "") return text;
+  return before;
+}
+function hasUnclosedCodeFence(text) {
+  const backticks = (text.match(/^[ \t]{0,3}```/gm) ?? []).length;
+  const tildes = (text.match(/^[ \t]{0,3}~~~/gm) ?? []).length;
+  return backticks % 2 === 1 || tildes % 2 === 1;
+}
+function hideIncompleteLink(text) {
+  let open = -1;
+  for (let i = text.length - 1; i >= 0; i--) {
+    if (text[i] === "[" && text[i - 1] !== "\\") {
+      open = i;
+      break;
+    }
+  }
+  if (open === -1) return text;
+  const start = open > 0 && text[open - 1] === "!" ? open - 1 : open;
+  const rest = text.slice(open);
+  if (!rest.includes("]")) {
+    return text.slice(0, start);
+  }
+  if (/^\[[^\]]*\]\([^)]*$/.test(rest)) {
+    return text.slice(0, start);
+  }
+  return text;
+}
+function repairIncompleteMath(text, showUnfinishedLatexBlocks) {
+  const countOf = (pattern) => (text.match(pattern) ?? []).length;
+  const opens = [];
+  if (countOf(/\\\[/g) > countOf(/\\\]/g)) {
+    opens.push({
+      index: text.lastIndexOf("\\["),
+      open: "\\[",
+      close: "\\]",
+      block: true,
+      display: true
+    });
+  }
+  if (countOf(/\\\(/g) > countOf(/\\\)/g)) {
+    opens.push({
+      index: text.lastIndexOf("\\("),
+      open: "\\(",
+      close: "",
+      block: false,
+      display: false
+    });
+  }
+  if (countOf(/\$\$/g) % 2 === 1) {
+    opens.push({
+      index: text.lastIndexOf("$$"),
+      open: "$$",
+      close: "$$",
+      block: true,
+      display: true
+    });
+  } else {
+    const masked = text.replace(/\$\$/g, "  ");
+    let lastDollar = -1;
+    for (const match of masked.matchAll(/(?<!\\)\$(?!\d)/g)) {
+      lastDollar = match.index;
+    }
+    const singles = masked.match(/(?<!\\)\$(?!\d)/g) ?? [];
+    if (singles.length % 2 === 1 && lastDollar !== -1) {
+      opens.push({
+        index: lastDollar,
+        open: "$",
+        close: "",
+        block: false,
+        display: false
+      });
+    }
+  }
+  const valid = opens.filter((entry) => entry.index >= 0);
+  if (valid.length === 0) return text;
+  const open = valid.reduce((a, b) => b.index < a.index ? b : a);
+  const before = text.slice(0, open.index);
+  if (!open.block) {
+    return before;
+  }
+  if (!showUnfinishedLatexBlocks) {
+    return before;
+  }
+  const inner = text.slice(open.index + open.open.length);
+  const body = bestRenderableMathBody(inner, open.display);
+  if (body == null) return before;
+  const blockLayout = /^[ \t]*\r?\n/.test(inner);
+  if (!blockLayout) {
+    return before + open.open + body + open.close;
+  }
+  const opener = before === "" || before.endsWith("\n") ? open.open : `
+${open.open}`;
+  return `${before}${opener}${body.replace(/\s+$/, "")}
+${open.close}`;
+}
+function bestRenderableMathBody(inner, display) {
+  const candidates = unclosedEnvironments(inner).length > 0 ? [closeOpenMathConstructs(truncateToLastRow(inner)), closeOpenMathConstructs(trimIncompleteMathTail(inner))] : [closeOpenMathConstructs(trimIncompleteMathTail(inner))];
+  for (const candidate of candidates) {
+    if (!hasRenderableMathContent(candidate)) continue;
+    if (isRenderableMath(candidate, display)) return candidate;
+  }
+  return null;
+}
+function hasRenderableMathContent(body) {
+  const stripped = body.replace(/\\(?:begin|end)\s*\{[^}]*\}/g, "").replace(/[\s{}]/g, "");
+  return stripped.length > 0;
+}
+function isRenderableMath(body, display) {
+  try {
+    katex.renderToString(body, {
+      displayMode: display,
+      throwOnError: true,
+      strict: false
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function truncateToLastRow(inner) {
+  const lastRow = inner.lastIndexOf("\\\\");
+  if (lastRow === -1) return "";
+  return inner.slice(0, lastRow + 2);
+}
+function trimIncompleteMathTail(inner) {
+  let result = inner;
+  let previous;
+  do {
+    previous = result;
+    result = result.replace(/\s+$/, "");
+    const backslashes = result.match(/\\+$/);
+    if (backslashes != null && backslashes[0].length % 2 === 1) {
+      result = result.slice(0, -1);
+    }
+    result = result.replace(/\\[a-zA-Z]+\*?$/, "");
+    result = result.replace(/[_^]$/, "");
+  } while (result !== previous);
+  return result;
+}
+function closeOpenMathConstructs(inner) {
+  let result = inner;
+  const lefts = (result.match(/\\left(?![a-zA-Z])/g) ?? []).length;
+  const rights = (result.match(/\\right(?![a-zA-Z])/g) ?? []).length;
+  result += "\\right.".repeat(Math.max(0, lefts - rights));
+  result += "}".repeat(openBraceDepth(result));
+  const environments = unclosedEnvironments(result);
+  for (let i = environments.length - 1; i >= 0; i--) {
+    result += `\\end{${environments[i]}}`;
+  }
+  return result;
+}
+function openBraceDepth(text) {
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === "{") depth++;
+    else if (char === "}" && depth > 0) depth--;
+  }
+  return depth;
+}
+function unclosedEnvironments(text) {
+  const stack = [];
+  const pattern = /\\(begin|end)\s*\{([^}]*)\}/g;
+  let match;
+  while ((match = pattern.exec(text)) != null) {
+    const name = match[2];
+    if (match[1] === "begin") {
+      stack.push(name);
+    } else {
+      const index = stack.lastIndexOf(name);
+      if (index !== -1) stack.splice(index, 1);
+      else stack.pop();
+    }
+  }
+  return stack;
+}
+function closeUnbalancedEmphasis(text) {
+  let result = text;
+  result = closeRunMarker(result, "~~");
+  result = closeSingleAsterisk(result);
+  result = closeRunMarker(result, "**");
+  result = closeSingleUnderscore(result);
+  result = closeDoubleUnderscore(result);
+  return result;
+}
+function opensAtWordBoundary(text, index) {
+  if (index <= 0) return true;
+  return !/[\p{L}\p{N}_]/u.test(text[index - 1]);
+}
+function closeSingleUnderscore(text) {
+  const masked = text.replace(/__/g, "");
+  const count = (masked.match(/_/g) ?? []).length;
+  if (count % 2 === 0) return text;
+  const lastIndex = text.lastIndexOf("_");
+  const after = text.slice(lastIndex + 1);
+  if (after.length === 0 || /^[\s_]/.test(after)) return text;
+  if (!opensAtWordBoundary(text, lastIndex)) return text;
+  return insertBeforeTrailingWhitespace(text, "_");
+}
+function closeDoubleUnderscore(text) {
+  const count = (text.match(/__/g) ?? []).length;
+  if (count % 2 === 0) return text;
+  const lastIndex = text.lastIndexOf("__");
+  const after = text.slice(lastIndex + 2);
+  if (after.length === 0 || /^\s/.test(after)) return text;
+  if (!opensAtWordBoundary(text, lastIndex)) return text;
+  return insertBeforeTrailingWhitespace(text, "__");
+}
+function closeRunMarker(text, marker) {
+  const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const count = (text.match(new RegExp(escaped, "g")) ?? []).length;
+  if (count % 2 === 0) return text;
+  const lastIndex = text.lastIndexOf(marker);
+  const after = text.slice(lastIndex + marker.length);
+  if (after.length === 0 || /^\s/.test(after)) return text;
+  return insertBeforeTrailingWhitespace(text, marker);
+}
+function closeSingleAsterisk(text) {
+  const masked = text.replace(/\*\*/g, "");
+  const count = (masked.match(/\*/g) ?? []).length;
+  if (count % 2 === 0) return text;
+  const lastIndex = text.lastIndexOf("*");
+  const after = text.slice(lastIndex + 1);
+  if (after.length === 0 || /^[\s*]/.test(after)) return text;
+  return insertBeforeTrailingWhitespace(text, "*");
+}
+function insertBeforeTrailingWhitespace(text, marker) {
+  const trailing = text.match(/\s+$/)?.[0] ?? "";
+  const core = text.slice(0, text.length - trailing.length);
+  return core + marker + trailing;
+}
+function CopyIcon() {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      viewBox: "0 0 24 24",
+      width: "1em",
+      height: "1em",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", ry: "2" }),
+        /* @__PURE__ */ jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+      ]
+    }
+  );
+}
+function CheckIcon() {
+  return /* @__PURE__ */ jsx(
+    "svg",
+    {
+      viewBox: "0 0 24 24",
+      width: "1em",
+      height: "1em",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      children: /* @__PURE__ */ jsx("path", { d: "M20 6 9 17l-5-5" })
+    }
+  );
+}
+function CopyButton({ text, className }) {
+  const [copied, setCopied] = useState(false);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current != null) clearTimeout(timeoutRef.current);
+    };
+  }, []);
+  const copy = () => {
+    const clipboard = navigator.clipboard;
+    if (!clipboard) return;
+    void clipboard.writeText(text).then(() => {
+      setCopied(true);
+      if (timeoutRef.current != null) clearTimeout(timeoutRef.current);
+      timeoutRef.current = setTimeout(() => setCopied(false), 2e3);
+    }).catch(() => {
+    });
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: copy,
+      className,
+      "aria-label": copied ? "Copied" : "Copy code",
+      "data-copied": copied ? "" : void 0,
+      children: copied ? /* @__PURE__ */ jsx(CheckIcon, {}) : /* @__PURE__ */ jsx(CopyIcon, {})
+    }
+  );
+}
+
+// src/preprocess.ts
+var CODE_SPAN = /```[\s\S]*?```|`[^`\n]+`/;
+function preprocessLaTeX(content) {
+  const codeBlocks = [];
+  content = content.replace(
+    new RegExp(`(${CODE_SPAN.source})`, "g"),
+    (_match, code) => {
+      codeBlocks.push(code);
+      return `<<CODE_BLOCK_${codeBlocks.length - 1}>>`;
+    }
+  );
+  const latexExpressions = [];
+  content = content.replace(
+    /(\$\$[\s\S]*?\$\$|\\\[[\s\S]*?\\\]|\\\(.*?\\\))/g,
+    (match) => {
+      latexExpressions.push(match);
+      return `<<LATEX_${latexExpressions.length - 1}>>`;
+    }
+  );
+  content = content.replace(/\$(?=\d)/g, "\\$");
+  content = content.replace(
+    /<<LATEX_(\d+)>>/g,
+    (_, index) => latexExpressions[parseInt(index, 10)]
+  );
+  content = content.replace(
+    /<<CODE_BLOCK_(\d+)>>/g,
+    (_, index) => codeBlocks[parseInt(index, 10)]
+  );
+  content = escapeBrackets(content);
+  content = escapeMhchem(content);
+  return content;
+}
+function escapeBrackets(text) {
+  const pattern = new RegExp(
+    `(${CODE_SPAN.source})|` + /\\\[((?:[\s\S]*?[^\\])?)\\]|\\\((.*?)\\\)/.source,
+    "g"
+  );
+  return text.replace(
+    pattern,
+    (match, codeBlock, squareBracket, roundBracket) => {
+      if (codeBlock != null) {
+        return codeBlock;
+      } else if (squareBracket != null) {
+        return `$$${squareBracket}$$`;
+      } else if (roundBracket != null) {
+        return `$${roundBracket}$`;
+      }
+      return match;
+    }
+  );
+}
+function escapeMhchem(text) {
+  return text.replaceAll("$\\ce{", "$\\\\ce{").replaceAll("$\\pu{", "$\\\\pu{");
+}
+var remarkPlugins = [remarkGfm, remarkMath];
+var rehypePlugins = [rehypeKatex];
+function cx(...inputs) {
+  const result = clsx(inputs);
+  return result === "" ? void 0 : result;
+}
+function buildComponents(classNames, overrides, highlighter) {
+  const cn = classNames ?? {};
+  const o = overrides ?? {};
+  const Highlighter = highlighter;
+  return {
+    code({ node: _node, className, children, ...props }) {
+      const match = /language-(\w+)/.exec(className || "");
+      const codeText = String(children).replace(/\n$/, "");
+      const isBlock = match != null || String(children).includes("\n");
+      if (isBlock) {
+        const language = match?.[1] ?? "";
+        if (o.codeBlock) {
+          const CodeBlock = o.codeBlock;
+          return /* @__PURE__ */ jsx(
+            CodeBlock,
+            {
+              code: codeText,
+              language,
+              className: cn.codeBlock
+            }
+          );
+        }
+        return /* @__PURE__ */ jsxs("div", { className: cx("llm-code-block", cn.codeBlock), children: [
+          /* @__PURE__ */ jsxs("div", { className: cx("llm-code-header", cn.codeHeader), children: [
+            /* @__PURE__ */ jsx("span", { className: cx("llm-code-language", cn.codeLanguage), children: language }),
+            o.copyButton ? /* @__PURE__ */ jsx(o.copyButton, { text: codeText, className: cn.copyButton }) : /* @__PURE__ */ jsx(
+              CopyButton,
+              {
+                text: codeText,
+                className: cx("llm-copy-button", cn.copyButton)
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "llm-code-body", children: Highlighter ? /* @__PURE__ */ jsx(Highlighter, { code: codeText, language }) : /* @__PURE__ */ jsx("code", { className: "llm-code-plain", children: codeText }) })
+        ] });
+      }
+      if (o.code) {
+        const InlineCode = o.code;
+        return /* @__PURE__ */ jsx(InlineCode, { className: cx("llm-code", cn.code, className), children });
+      }
+      return /* @__PURE__ */ jsx("code", { className: cx("llm-code", cn.code, className), ...props, children });
+    },
+    pre({ children }) {
+      if (o.pre) {
+        return /* @__PURE__ */ jsx(o.pre, { children });
+      }
+      return /* @__PURE__ */ jsx(Fragment, { children });
+    },
+    table({ children }) {
+      if (o.table) {
+        return /* @__PURE__ */ jsx(o.table, { className: cn.table, children });
+      }
+      return /* @__PURE__ */ jsx("div", { className: cx("llm-table-wrapper", cn.tableWrapper), children: /* @__PURE__ */ jsx("table", { className: cx("llm-table", cn.table), children }) });
+    },
+    th({ children }) {
+      if (o.th) {
+        return /* @__PURE__ */ jsx(o.th, { className: cn.th, children });
+      }
+      return /* @__PURE__ */ jsx("th", { className: cx("llm-th", cn.th), children });
+    },
+    td({ children }) {
+      if (o.td) {
+        return /* @__PURE__ */ jsx(o.td, { className: cn.td, children });
+      }
+      return /* @__PURE__ */ jsx("td", { className: cx("llm-td", cn.td), children });
+    },
+    blockquote({ children }) {
+      if (o.blockquote) {
+        return /* @__PURE__ */ jsx(o.blockquote, { className: cn.blockquote, children });
+      }
+      return /* @__PURE__ */ jsx("blockquote", { className: cx("llm-blockquote", cn.blockquote), children });
+    },
+    ul({ children }) {
+      if (o.ul) {
+        return /* @__PURE__ */ jsx(o.ul, { className: cn.ul, children });
+      }
+      return /* @__PURE__ */ jsx("ul", { className: cx("llm-ul", cn.ul), children });
+    },
+    ol({ children }) {
+      if (o.ol) {
+        return /* @__PURE__ */ jsx(o.ol, { className: cn.ol, children });
+      }
+      return /* @__PURE__ */ jsx("ol", { className: cx("llm-ol", cn.ol), children });
+    },
+    li({ children }) {
+      if (o.li) {
+        return /* @__PURE__ */ jsx(o.li, { className: cn.li, children });
+      }
+      return /* @__PURE__ */ jsx("li", { className: cx("llm-li", cn.li), children });
+    },
+    p({ children }) {
+      if (o.p) {
+        return /* @__PURE__ */ jsx(o.p, { className: cn.p, children });
+      }
+      return /* @__PURE__ */ jsx("p", { className: cx("llm-p", cn.p), children });
+    },
+    h1({ children }) {
+      if (o.h1) {
+        return /* @__PURE__ */ jsx(o.h1, { className: cn.h1, children });
+      }
+      return /* @__PURE__ */ jsx("h1", { className: cx("llm-h1", cn.h1), children });
+    },
+    h2({ children }) {
+      if (o.h2) {
+        return /* @__PURE__ */ jsx(o.h2, { className: cn.h2, children });
+      }
+      return /* @__PURE__ */ jsx("h2", { className: cx("llm-h2", cn.h2), children });
+    },
+    h3({ children }) {
+      if (o.h3) {
+        return /* @__PURE__ */ jsx(o.h3, { className: cn.h3, children });
+      }
+      return /* @__PURE__ */ jsx("h3", { className: cx("llm-h3", cn.h3), children });
+    },
+    h4({ children }) {
+      if (o.h4) {
+        return /* @__PURE__ */ jsx(o.h4, { className: cn.h4, children });
+      }
+      return /* @__PURE__ */ jsx("h4", { className: cx("llm-h4", cn.h4), children });
+    },
+    h5({ children }) {
+      if (o.h5) {
+        return /* @__PURE__ */ jsx(o.h5, { className: cn.h5, children });
+      }
+      return /* @__PURE__ */ jsx("h5", { className: cx("llm-h5", cn.h5), children });
+    },
+    h6({ children }) {
+      if (o.h6) {
+        return /* @__PURE__ */ jsx(o.h6, { className: cn.h6, children });
+      }
+      return /* @__PURE__ */ jsx("h6", { className: cx("llm-h6", cn.h6), children });
+    },
+    input({ node: _node, type, checked, disabled, ...props }) {
+      if (type === "checkbox") {
+        if (o.checkbox) {
+          return /* @__PURE__ */ jsx(o.checkbox, { checked: Boolean(checked), className: cn.checkbox });
+        }
+        return /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: Boolean(checked),
+            disabled: true,
+            "aria-label": checked ? "Completed task" : "Incomplete task",
+            className: cx("llm-checkbox", cn.checkbox),
+            readOnly: true
+          }
+        );
+      }
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type,
+          checked,
+          disabled,
+          readOnly: true,
+          ...props
+        }
+      );
+    },
+    a({ href, children }) {
+      if (o.a) {
+        return /* @__PURE__ */ jsx(o.a, { href, className: cn.a, children });
+      }
+      return /* @__PURE__ */ jsx(
+        "a",
+        {
+          href,
+          target: "_blank",
+          rel: "noopener noreferrer",
+          className: cx("llm-a", cn.a),
+          children
+        }
+      );
+    },
+    img({ node: _node, src, alt, title, className: _className, ...props }) {
+      if (o.img) {
+        const Image = o.img;
+        return /* @__PURE__ */ jsx(
+          Image,
+          {
+            src: typeof src === "string" ? src : void 0,
+            alt,
+            title,
+            className: cn.img
+          }
+        );
+      }
+      return /* @__PURE__ */ jsx(
+        "img",
+        {
+          src: typeof src === "string" ? src : void 0,
+          alt,
+          title,
+          className: cx("llm-img", cn.img),
+          ...props
+        }
+      );
+    },
+    hr() {
+      if (o.hr) {
+        return /* @__PURE__ */ jsx(o.hr, { className: cn.hr });
+      }
+      return /* @__PURE__ */ jsx("hr", { className: cx("llm-hr", cn.hr) });
+    },
+    strong({ children }) {
+      if (o.strong) {
+        return /* @__PURE__ */ jsx(o.strong, { className: cn.strong, children });
+      }
+      return /* @__PURE__ */ jsx("strong", { className: cx("llm-strong", cn.strong), children });
+    },
+    em({ children }) {
+      if (o.em) {
+        return /* @__PURE__ */ jsx(o.em, { className: cn.em, children });
+      }
+      return /* @__PURE__ */ jsx("em", { className: cx("llm-em", cn.em), children });
+    },
+    del({ children }) {
+      if (o.del) {
+        return /* @__PURE__ */ jsx(o.del, { className: cn.del, children });
+      }
+      return /* @__PURE__ */ jsx("del", { className: cx("llm-del", cn.del), children });
+    }
+  };
+}
+function LLMMessage({
+  children,
+  content,
+  className,
+  classNames,
+  components,
+  completePartialTokens: repairPartialTokens = true,
+  showUnfinishedLatexBlocks = true,
+  highlighter,
+  ...rest
+}) {
+  const source = content ?? children ?? "";
+  const markdownComponents = useMemo(
+    () => buildComponents(classNames, components, highlighter),
+    [classNames, components, highlighter]
+  );
+  const processed = useMemo(() => {
+    const repaired = repairPartialTokens ? completePartialTokens(source, { showUnfinishedLatexBlocks }) : source;
+    return preprocessLaTeX(repaired);
+  }, [source, repairPartialTokens, showUnfinishedLatexBlocks]);
+  return /* @__PURE__ */ jsx("div", { className: cx("llm-message", classNames?.root, className), ...rest, children: /* @__PURE__ */ jsx(
+    ReactMarkdown,
+    {
+      remarkPlugins,
+      rehypePlugins,
+      components: markdownComponents,
+      children: processed
+    }
+  ) });
+}
+
+export { LLMMessage, completePartialTokens, escapeBrackets, escapeMhchem, preprocessLaTeX };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map