,
: the mixed text+math path\n // below wraps each part in its own element, which would cut a paragraph\n // in half across a math expression.
is inline and survives the split\n // intact — and `[&_p]:mb-0` below means paragraphs carry no spacing here\n // anyway, so there is nothing to gain from block elements.\n const normalizedContent = normalizeLineBreaksInHtml(content, {\n inline: true,\n });\n\n const processedContent = sanitize\n ? sanitizeHtmlForDisplay(normalizedContent)\n : normalizedContent;\n\n const parts = processHtmlWithMath(processedContent);\n\n // If all parts are text (or empty), render as plain HTML. Use the\n // joined parts (not the raw `processedContent`) so post-split fixes\n // applied inside `processHtmlWithMath` — like decoding `\\$` escapes\n // to literal `$` — actually reach the rendered output.\n if (parts.every((part) => part.type === 'text')) {\n const joinedHtml = parts.map((part) => part.content).join('');\n // Use span for inline mode to allow valid nesting in labels\n const Element = inline ? 'span' : 'div';\n return (\n
`,\n * ``, ``). The two sources are\n * cleanly separable, so we bias toward the proven HTML path:\n *\n * - If any real HTML element tag is present we return `false` and let\n * `HtmlMathRenderer` handle it exactly as before (math-formula spans,\n * currency heuristic, katex-error recovery, sanitization).\n * - Otherwise we return `true` only when an unmistakable Markdown marker is\n * present (ATX heading, bold, bullet/ordered list, GFM table, or a paragraph\n * break), which is what breaks today: Markdown rendered as HTML shows the raw\n * `**`/`####`/`*` tokens and collapses line breaks.\n *\n * Regex note: line-anchored signals use the `m` flag with `^` and restrict\n * horizontal whitespace to `[ \\t]` (never `\\s`, which also matches `\\n`). This\n * keeps each quantifier on a single line and avoids the super-linear\n * backtracking that `(?:^|\\n)\\s*…\\s+` can trigger across newlines.\n */\nexport const isLikelyMarkdown = (content: string): boolean => {\n if (!content) return false;\n\n // Presence of real HTML element tags => treat as HTML (RichEditor output).\n if (containsHtmlTag(content)) return false;\n\n const MARKDOWN_SIGNALS = [\n /^#{1,6}[ \\t]+\\S/m, // ATX heading (#, ##, ... ######)\n /\\*\\*[^*\\n]+\\*\\*/, // bold\n /__[^_\\n]+__/, // bold (underscore)\n /^[ \\t]*[-*+][ \\t]+\\S/m, // bullet list\n /^[ \\t]*\\d+\\.[ \\t]+\\S/m, // ordered list\n /\\|[ \\t]*:?-+:?[ \\t]*\\|/, // GFM table delimiter row (|---|---|)\n /\\n\\n/, // paragraph break (only reached when no HTML tag is present)\n ];\n return MARKDOWN_SIGNALS.some((pattern) => pattern.test(content));\n};\n\n/**\n * Recovers usable LaTeX source from `` wrappers\n * that previous editor cycles persisted into the database. The error's\n * `title` attribute carries the original LaTeX after \"at position N: \".\n * Replaces each wrapper with `$LATEX$` so downstream patterns can render\n * it cleanly via KaTeX.\n *\n * No-op outside browser contexts (no `document`).\n */\nconst recoverFromKatexErrorSpans = (htmlContent: string): string => {\n if (\n typeof document === 'undefined' ||\n !/class=\"[^\"]*katex-error/i.test(htmlContent)\n ) {\n return htmlContent;\n }\n\n const tempContainer = document.createElement('div');\n tempContainer.innerHTML = htmlContent;\n\n const sanitizeRecoveredLatex = (raw: string): string =>\n raw\n // Strip combining marks KaTeX puts in error titles at the error pos\n .replaceAll(/[\\u0300-\\u036F]/g, '')\n // Drop truncated tag markers leftover from broken serialization.\n // Done while literal `<`/`>` are still present (before they get\n // mapped to LaTeX commands below).\n .replaceAll(/<\\/?[a-zA-Z][a-zA-Z0-9]*\\s*>?$/g, '')\n // Map comparison operators to equivalent LaTeX commands. We match\n // both the entity forms AND the literal `<`/`>` characters: the\n // `title` attribute is entity-decoded by the DOM when read, so we\n // often get literal `<`/`>`. Mapping them to `\\lt`/`\\gt` also avoids\n // re-encoding to `<`/`>` on DOM serialization (which would make\n // `looksLikeLatex` reject the recovered block as non-math).\n // `&` decodes to a bare `&` (the LaTeX alignment character), not\n // `\\&`, so `\\begin{align}` environments survive recovery.\n .replaceAll(/<|<|/gi, String.raw`\\gt `)\n .replaceAll(/&|&/gi, '&')\n .trim();\n\n Array.from(tempContainer.querySelectorAll('.katex-error')).forEach(\n (errorNode) => {\n if (!tempContainer.contains(errorNode)) return;\n\n const title = errorNode.getAttribute('title') || '';\n // Note: no `\\s*` before the capture group — `\\s*(.+)` would let\n // whitespace be split ambiguously between the two, causing\n // super-linear backtracking (ReDoS). The capture is trimmed by\n // sanitizeRecoveredLatex below instead.\n const positionMatch = /at position\\s+\\d+:(.+)$/.exec(title);\n let recovered = positionMatch ? positionMatch[1] : '';\n\n if (!recovered) {\n // Fallback: collect from inner