| /** | |
| * Math / formula normalisation for student-facing AI answers. | |
| * | |
| * Pipeline (applied after sanitizeAIResponse): | |
| * 1. Convert LaTeX delimiters \( … \) → $ … $ (inline math) | |
| * 2. Convert LaTeX delimiters \[ … \] → $$ … $$ (display math) | |
| * 3. Collapse excess whitespace produced by stripping reasoning blocks. | |
| * | |
| * Formulas inside the resulting $ … $ blocks are left untouched — KaTeX | |
| * handles them at render time via remark-math + rehype-katex. | |
| * | |
| * chemicalText() is exported separately as a fallback plain-text formatter | |
| * for contexts where ReactMarkdown / KaTeX is not available (e.g. tooltips, | |
| * clipboard copy, alt-text). It converts common TeX subscripts/arrows to | |
| * Unicode equivalents. | |
| */ | |
| // --------------------------------------------------------------------------- | |
| // 1. LaTeX delimiter normalisation → remark-math compatible $ / $$ delimiters | |
| // --------------------------------------------------------------------------- | |
| /** | |
| * Convert \( … \) and \[ … \] delimiters to $ … $ and $$ … $$. | |
| * Also cleans up a handful of stray TeX artefacts that appear outside math | |
| * when models hallucinate raw LaTeX into prose. | |
| */ | |
| export function normalizeMathMarkdown(text: string): string { | |
| if (!text) return ""; | |
| let t = text; | |
| // 1a. Display math \[ … \] → $$ … $$ | |
| // Use non-greedy multiline match so one call handles multiple blocks. | |
| t = t.replace(/\\\[\s*([\s\S]*?)\s*\\\]/g, (_m, inner: string) => `$$${inner.trim()}$$`); | |
| // 1b. Inline math \( … \) → $ … $ | |
| t = t.replace(/\\\(\s*([\s\S]*?)\s*\\\)/g, (_m, inner: string) => `$${inner.trim()}$`); | |
| // 1c. Strip stray \text{} wrappers that ended up outside any math block | |
| // (models sometimes write \text{something} directly in prose). | |
| // Inside $…$ they are valid and must be left alone — handled by KaTeX. | |
| // This regex only removes them when NOT preceded by $ on the same line. | |
| t = t.replace(/\\text\{([^}]*)\}/g, (match, inner: string, offset: number) => { | |
| // Check if inside a $…$ block by counting $ signs before this position | |
| const before = t.slice(0, offset); | |
| const dollarsBefore = (before.match(/\$/g) ?? []).length; | |
| // If odd number of $ before → inside inline math → leave it (return original) | |
| if (dollarsBefore % 2 === 1) return match; | |
| return inner; // outside math — just keep the inner text | |
| }); | |
| // 1d. Replace \rightarrow and \to outside math blocks with → | |
| t = replaceOutsideMath(t, /\\(?:rightarrow|to)\b/g, "→"); | |
| // 1e. Replace \Rightarrow outside math blocks with ⟹ | |
| t = replaceOutsideMath(t, /\\Rightarrow\b/g, "⟹"); | |
| // 1f. Replace \cdot outside math with · | |
| t = replaceOutsideMath(t, /\\cdot\b/g, "·"); | |
| // 1g. Replace \times outside math with × | |
| t = replaceOutsideMath(t, /\\times\b/g, "×"); | |
| // 1h. Collapse 3+ blank lines (side-effect of removing reasoning blocks) | |
| t = t.replace(/\n{3,}/g, "\n\n").trim(); | |
| return t; | |
| } | |
| /** | |
| * Apply a regex replacement only to text segments that are outside $ math $ delimiters. | |
| * Walks the string, alternating between "outside math" and "inside math" segments. | |
| */ | |
| function replaceOutsideMath(text: string, pattern: RegExp, replacement: string): string { | |
| // Split on $ boundaries while preserving the delimiters | |
| const segments = text.split(/(\$\$[\s\S]*?\$\$|\$[^$\n]*?\$)/); | |
| return segments | |
| .map((seg, i) => { | |
| // Even indices → outside math; odd indices → inside a $…$ or $$…$$ block | |
| if (i % 2 === 0) return seg.replace(pattern, replacement); | |
| return seg; | |
| }) | |
| .join(""); | |
| } | |
| // --------------------------------------------------------------------------- | |
| // 2. Plain-text chemical / math formatter (fallback / clipboard) | |
| // --------------------------------------------------------------------------- | |
| const SUB_MAP: Record<string, string> = { | |
| "0": "₀", "1": "₁", "2": "₂", "3": "₃", "4": "₄", | |
| "5": "₅", "6": "₆", "7": "₇", "8": "₈", "9": "₉", | |
| }; | |
| const SUP_MAP: Record<string, string> = { | |
| "0": "⁰", "1": "¹", "2": "²", "3": "³", "4": "⁴", | |
| "5": "⁵", "6": "⁶", "7": "⁷", "8": "⁸", "9": "⁹", | |
| "+": "⁺", "-": "⁻", "n": "ⁿ", | |
| }; | |
| function toSubscript(digits: string): string { | |
| return [...digits].map((d) => SUB_MAP[d] ?? d).join(""); | |
| } | |
| function toSuperscript(digits: string): string { | |
| return [...digits].map((d) => SUP_MAP[d] ?? d).join(""); | |
| } | |
| /** | |
| * Convert chemical/math TeX into readable Unicode plain-text. | |
| * Designed for clipboard copy, tooltips, and accessibility alt-text. | |
| * | |
| * Examples: | |
| * C_6H_{12}O_6 → C₆H₁₂O₆ | |
| * CO_2 → CO₂ | |
| * H_2O → H₂O | |
| * x^2 → x² | |
| * \rightarrow → → | |
| * \text{foo} → foo | |
| * \( E = mc^2 \) → E = mc² | |
| */ | |
| export function chemicalText(raw: string): string { | |
| if (!raw) return ""; | |
| let t = raw; | |
| // Strip LaTeX display/inline delimiters | |
| t = t.replace(/\\\[|\\\]/g, "").replace(/\\\(|\\\)/g, ""); | |
| // \text{…} → inner text | |
| t = t.replace(/\\text\{([^}]*)\}/g, "$1"); | |
| // Arrows and operators — keep trailing space (→ B, × 3 etc.) | |
| t = t.replace(/\\(?:rightarrow|to)\b/g, "→"); | |
| t = t.replace(/\\Rightarrow\b/g, "⟹"); | |
| t = t.replace(/\\(?:leftarrow)\b/g, "←"); | |
| t = t.replace(/\\cdot\b/g, "·"); | |
| t = t.replace(/\\times\b/g, "×"); | |
| t = t.replace(/\\pm\b/g, "±"); | |
| t = t.replace(/\\infty\b/g, "∞"); | |
| // Uppercase Greek used as thermodynamic prefix symbols (ΔH, ΔG, ΔS, ΣF …) | |
| // These appear as "\Delta H" in LaTeX — the space is a LaTeX artifact, not prose space. | |
| // Consume optional trailing space so output is "ΔH" not "Δ H". | |
| t = t.replace(/\\Delta\b\s*/g, "Δ"); | |
| t = t.replace(/\\Gamma\b\s*/g, "Γ"); | |
| t = t.replace(/\\Sigma\b\s*/g, "Σ"); | |
| // Lowercase Greek — keep trailing space (λ = 500, not λ=500) | |
| t = t.replace(/\\alpha\b/g, "α"); | |
| t = t.replace(/\\beta\b/g, "β"); | |
| t = t.replace(/\\gamma\b/g, "γ"); | |
| t = t.replace(/\\lambda\b/g, "λ"); | |
| t = t.replace(/\\mu\b/g, "μ"); | |
| t = t.replace(/\\pi\b/g, "π"); | |
| t = t.replace(/\\theta\b/g, "θ"); | |
| t = t.replace(/\\omega\b/g, "ω"); | |
| t = t.replace(/\\sigma\b/g, "σ"); | |
| // Subscript: _{12} or _2 | |
| t = t.replace(/\_\{([0-9+\-n]+)\}/g, (_m, d: string) => toSubscript(d)); | |
| t = t.replace(/\_([0-9])/g, (_m, d: string) => toSubscript(d)); | |
| // Superscript: ^{2} or ^2 | |
| t = t.replace(/\^\{([0-9+\-n]+)\}/g, (_m, d: string) => toSuperscript(d)); | |
| t = t.replace(/\^([0-9+\-n])/g, (_m, d: string) => toSuperscript(d)); | |
| // Strip remaining bare backslash-commands we didn't handle | |
| t = t.replace(/\\[a-zA-Z]+\b/g, ""); | |
| // Strip leftover braces | |
| t = t.replace(/[{}]/g, ""); | |
| return t.trim(); | |
| } | |