import html import re GREEK_LETTERS = { "alpha": "α", "beta": "β", "gamma": "γ", "delta": "δ", "epsilon": "ε", "varepsilon": "ε", "zeta": "ζ", "eta": "η", "theta": "θ", "vartheta": "ϑ", "iota": "ι", "kappa": "κ", "lambda": "λ", "mu": "μ", "nu": "ν", "xi": "ξ", "pi": "π", "varpi": "ϖ", "rho": "ρ", "varrho": "ρ", "sigma": "σ", "varsigma": "ς", "tau": "τ", "upsilon": "υ", "phi": "φ", "varphi": "φ", "chi": "χ", "psi": "ψ", "omega": "ω", "Gamma": "Γ", "Delta": "Δ", "Theta": "Θ", "Lambda": "Λ", "Xi": "Ξ", "Pi": "Π", "Sigma": "Σ", "Upsilon": "Υ", "Phi": "Φ", "Psi": "Ψ", "Omega": "Ω" } MATH_SYMBOLS = { "times": "×", "cdot": "·", "div": "÷", "pm": "±", "mp": "∓", "le": "≤", "leq": "≤", "ge": "≥", "geq": "≥", "neq": "≠", "ne": "≠", "approx": "≈", "equiv": "≡", "infty": "∞", "partial": "∂", "nabla": "∇", "sum": "∑", "prod": "∏", "int": "∫", "iint": "∬", "iiint": "∭", "oint": "∮", "rightarrow": "→", "to": "→", "leftarrow": "←", "Rightarrow": "⇒", "Leftarrow": "⇐", "Leftrightarrow": "⇔", "iff": "⇔", "implies": "⇒", "forall": "∀", "exists": "∃", "nexists": "∄", "in": "∈", "notin": "∉", "subset": "⊂", "subseteq": "⊆", "supset": "⊃", "supseteq": "⊇", "cup": "∪", "cap": "∩", "setminus": "∖", "circ": "°", "degree": "°", "ldots": "…", "cdots": "⋯", "vdots": "⋮", "ddots": "⋱", "quad": "    ", "qquad": "        ", "sim": "~", "propto": "∝", "perp": "⊥", "parallel": "∥", "langle": "⟨", "rangle": "⟩", "lceil": "⌈", "rceil": "⌉", "lfloor": "⌊", "rfloor": "⌋", "dagger": "†", "star": "★", "checkmark": "✓", "prime": "′", } BLACKBOARD_BOLD = { "N": "ℕ", "Z": "ℤ", "Q": "ℚ", "R": "ℝ", "C": "ℂ", "P": "ℙ", "H": "ℍ", "E": "𝔼", "1": "𝟙" } def extract_balanced_braces(text: str, start_index: int) -> tuple[str, int]: """ Finds the content of balanced curly braces { ... } starting at start_index. Returns (content, next_index_after_closing_brace). """ if start_index >= len(text) or text[start_index] != '{': return "", start_index depth = 0 start = start_index + 1 for i in range(start_index, len(text)): if text[i] == '{': depth += 1 elif text[i] == '}': depth -= 1 if depth == 0: return text[start:i], i + 1 return text[start:], len(text) def extract_balanced_brackets(text: str, start_index: int) -> tuple[str, int]: """ Finds the content of balanced square brackets [ ... ] starting at start_index. """ if start_index >= len(text) or text[start_index] != '[': return "", start_index depth = 0 start = start_index + 1 for i in range(start_index, len(text)): if text[i] == '[': depth += 1 elif text[i] == ']': depth -= 1 if depth == 0: return text[start:i], i + 1 return text[start:], len(text) def render_latex_math(expr: str, is_block: bool = False) -> str: """ Recursively renders all LaTeX commands, fractions, matrices, nested boxed expressions, and symbols into rich styled HTML. """ expr = expr.strip() if not expr: return "" # 1. Clean delimiters \left and \right expr = re.sub(r'\\left\s*([(\[{|.])', r'\1', expr) expr = re.sub(r'\\right\s*([)\]}|.])', r'\1', expr) # 2. Process \boxed{...} with nested brace support while r"\boxed" in expr: idx = expr.find(r"\boxed") brace_idx = expr.find("{", idx) if brace_idx != -1 and brace_idx - (idx + 6) <= 2: inner_content, next_idx = extract_balanced_braces(expr, brace_idx) rendered_inner = render_latex_math(inner_content, is_block=False) boxed_html = ( f'{rendered_inner}' ) expr = expr[:idx] + boxed_html + expr[next_idx:] else: break # 3. Process fractions: \frac, \dfrac, \tfrac, \cfrac with nested braces frac_patterns = [r"\dfrac", r"\tfrac", r"\cfrac", r"\frac"] found_frac = True while found_frac: found_frac = False for fp in frac_patterns: if fp in expr: idx = expr.find(fp) brace1_idx = expr.find("{", idx) if brace1_idx != -1 and brace1_idx - (idx + len(fp)) <= 2: num_content, after_num = extract_balanced_braces(expr, brace1_idx) brace2_idx = expr.find("{", after_num) if brace2_idx != -1 and brace2_idx - after_num <= 2: den_content, after_den = extract_balanced_braces(expr, brace2_idx) rendered_num = render_latex_math(num_content, is_block=False) rendered_den = render_latex_math(den_content, is_block=False) frac_html = ( f'' f'{rendered_num}' f'{rendered_den}' f'' ) expr = expr[:idx] + frac_html + expr[after_den:] found_frac = True break # 4. Process \binom{n}{k} while r"\binom" in expr: idx = expr.find(r"\binom") brace1_idx = expr.find("{", idx) if brace1_idx != -1: top_c, after_top = extract_balanced_braces(expr, brace1_idx) brace2_idx = expr.find("{", after_top) if brace2_idx != -1: bot_c, after_bot = extract_balanced_braces(expr, brace2_idx) binom_html = ( f'' f'(' f'' f'{render_latex_math(top_c)}' f'{render_latex_math(bot_c)}' f'' f')' f'' ) expr = expr[:idx] + binom_html + expr[after_bot:] else: break else: break # 5. Process \sqrt[n]{x} and \sqrt{x} while r"\sqrt" in expr: idx = expr.find(r"\sqrt") bracket_idx = expr.find("[", idx) brace_idx = expr.find("{", idx) if bracket_idx != -1 and (brace_idx == -1 or bracket_idx < brace_idx) and bracket_idx - (idx + 5) <= 2: deg, after_deg = extract_balanced_brackets(expr, bracket_idx) brace_idx2 = expr.find("{", after_deg) if brace_idx2 != -1: inner, after_inner = extract_balanced_braces(expr, brace_idx2) rendered_inner = render_latex_math(inner, is_block=False) sqrt_html = f'{deg}√({rendered_inner})' expr = expr[:idx] + sqrt_html + expr[after_inner:] else: break elif brace_idx != -1 and brace_idx - (idx + 5) <= 2: inner, after_inner = extract_balanced_braces(expr, brace_idx) rendered_inner = render_latex_math(inner, is_block=False) sqrt_html = f'√({rendered_inner})' expr = expr[:idx] + sqrt_html + expr[after_inner:] else: expr = expr.replace(r"\sqrt", "√", 1) # 6. Process text styling: \text, \mathrm, \mathbf, \mathit, \mathbb, \mathcal style_commands = [ (r"\text", r"\1"), (r"\mathrm", r"\1"), (r"\mathbf", r"\1"), (r"\textbf", r"\1"), (r"\mathit", r"\1"), (r"\textit", r"\1"), (r"\underline", r"\1"), (r"\overline", r"\1") ] for cmd, fmt in style_commands: while cmd in expr: idx = expr.find(cmd) brace_idx = expr.find("{", idx) if brace_idx != -1 and brace_idx - (idx + len(cmd)) <= 2: inner, after_inner = extract_balanced_braces(expr, brace_idx) rendered = fmt.replace(r"\1", inner) expr = expr[:idx] + rendered + expr[after_inner:] else: break # 7. Blackboard bold \mathbb{R} -> ℝ while r"\mathbb" in expr: idx = expr.find(r"\mathbb") brace_idx = expr.find("{", idx) if brace_idx != -1: letter, after_letter = extract_balanced_braces(expr, brace_idx) sym = BLACKBOARD_BOLD.get(letter.strip(), letter) expr = expr[:idx] + sym + expr[after_letter:] else: break # 8. Environments: \begin{cases} ... \end{cases}, \begin{matrix}, etc. def replace_cases(m): rows = m.group(1).split(r"\\") html_rows = [] for r in rows: r_clean = render_latex_math(r.replace("&", "  "), is_block=False) html_rows.append(f"
{r_clean}
") return ( f'
' f'{' f'
{"".join(html_rows)}
' f'
' ) expr = re.sub(r'\\begin\{cases\}([\s\S]*?)\\end\{cases\}', replace_cases, expr) def replace_matrix(m): rows = m.group(2).split(r"\\") html_rows = [] for r in rows: cols = [render_latex_math(c, is_block=False) for c in r.split("&")] row_html = "".join([f"{c}" for c in cols]) html_rows.append(f"{row_html}") return ( f'{"".join(html_rows)}
' ) expr = re.sub(r'\\begin\{(matrix|pmatrix|bmatrix|vmatrix)\}([\s\S]*?)\\end\{\1\}', replace_matrix, expr) # 9. Replace Greek Letters and Operators for name, sym in GREEK_LETTERS.items(): expr = re.sub(r'\\' + name + r'\b', sym, expr) for op, sym in MATH_SYMBOLS.items(): expr = re.sub(r'\\' + op + r'\b', sym, expr) # Spacing commands expr = expr.replace(r"\,", " ").replace(r"\;", "  ").replace(r"\:", " ").replace(r"\!", "") # Exponents: x^{...} or x^2 while "^" in expr: idx = expr.find("^") if idx + 1 < len(expr) and expr[idx + 1] == '{': exp_content, after_exp = extract_balanced_braces(expr, idx + 1) rendered_exp = render_latex_math(exp_content, is_block=False) expr = expr[:idx] + f"{rendered_exp}" + expr[after_exp:] elif idx + 1 < len(expr) and expr[idx + 1].isalnum(): expr = expr[:idx] + f"{expr[idx+1]}" + expr[idx + 2:] else: break # Subscripts: x_{...} or x_1 while "_" in expr: idx = expr.find("_") if idx + 1 < len(expr) and expr[idx + 1] == '{': sub_content, after_sub = extract_balanced_braces(expr, idx + 1) rendered_sub = render_latex_math(sub_content, is_block=False) expr = expr[:idx] + f"{rendered_sub}" + expr[after_sub:] elif idx + 1 < len(expr) and expr[idx + 1].isalnum(): expr = expr[:idx] + f"{expr[idx+1]}" + expr[idx + 2:] else: break # Clean leftover unhandled LaTeX command words (e.g. \displaystyle, \limits) expr = re.sub(r'\\(displaystyle|textstyle|limits|nolimits|rm|sf|tt|bf|it|cal)\b', '', expr) expr = re.sub(r'\\([a-zA-Z]+)', r'\1', expr) if is_block: return ( f'
{expr}
' ) else: return ( f'{expr}' ) def format_markdown_and_latex(text: str) -> str: """ Parses Markdown, code blocks, lists, and any LaTeX formulas ($$, $, \[, \(, \boxed, \frac, \mathbb, etc.), returning rich styled HTML. """ if not text: return "" placeholders = [] def store_placeholder(html_snippet: str) -> str: idx = len(placeholders) placeholders.append(html_snippet) return f"QQQMAGITOKEN{idx}ZZZ" # 0. Preserve pre-existing styled HTML cards (e.g. Sandbox output blocks) def handle_raw_html_card(m): return store_placeholder(m.group(0)) text = re.sub(r'[\s\S]*?', handle_raw_html_card, text) text = re.sub(r'
', handle_raw_html_card, text) # 1. Code blocks (preserve exact content) def handle_code_block(m): code_text = html.escape(m.group(2)) block_html = ( f'
'
            f'{code_text}
' ) return store_placeholder(block_html) text = re.sub(r'```([a-zA-Z0-9_-]*)\n?(.*?)```', handle_code_block, text, flags=re.DOTALL) # 2. Display LaTeX Blocks ($$...$$ and \[...\]) def handle_block_math(m): math_html = render_latex_math(m.group(1), is_block=True) return store_placeholder(math_html) text = re.sub(r'\$\$([\s\S]*?)\$\$', handle_block_math, text) text = re.sub(r'\\\[([\s\S]*?)\\\]', handle_block_math, text) # 3. Inline LaTeX Math ($...$ and \(...\)) def handle_inline_math(m): inner = m.group(1).strip() if "\n\n" in inner: return m.group(0) # Avoid treating plain currency or numbers like $25, $10.50 as LaTeX math if re.match(r'^\d+(\.\d+)?$', inner) or re.match(r'^\d+\s*(to|-)\s*\d+$', inner, re.IGNORECASE): return m.group(0) # Must contain letters, LaTeX symbols, operators, or backslashes to qualify as math if not re.search(r'[a-zA-Z\\_^=+<>\-*/()\[\]{}&]', inner): return m.group(0) math_html = render_latex_math(inner, is_block=False) return store_placeholder(math_html) text = re.sub(r'\$([^\$\n]+?)\$', handle_inline_math, text) text = re.sub(r'\\\(([\s\S]*?)\\\)', handle_inline_math, text) # 4. Standalone \boxed{...} with nested brace support while r"\boxed" in text: idx = text.find(r"\boxed") brace_idx = text.find("{", idx) if brace_idx != -1 and brace_idx - (idx + 6) <= 2: inner_c, after_idx = extract_balanced_braces(text, brace_idx) rendered_b = render_latex_math(r"\boxed{" + inner_c + r"}", is_block=False) placeholder = store_placeholder(rendered_b) text = text[:idx] + placeholder + text[after_idx:] else: break # 5. Standalone raw LaTeX math commands (when not enclosed in $) standalone_commands = [ r"\dfrac", r"\tfrac", r"\cfrac", r"\frac", r"\binom", r"\sqrt", r"\mathbb", r"\mathbf", r"\mathrm", r"\mathit", r"\begin{cases}", r"\begin{matrix}", r"\begin{pmatrix}", r"\begin{bmatrix}" ] for cmd in standalone_commands: while cmd in text: idx = text.find(cmd) end_idx = idx + len(cmd) while end_idx < len(text) and (text[end_idx].isspace() or text[end_idx] in "{["): if text[end_idx] == '{': _, end_idx = extract_balanced_braces(text, end_idx) elif text[end_idx] == '[': _, end_idx = extract_balanced_brackets(text, end_idx) else: end_idx += 1 math_segment = text[idx:end_idx] rendered_seg = render_latex_math(math_segment, is_block=False) placeholder = store_placeholder(rendered_seg) text = text[:idx] + placeholder + text[end_idx:] # 6. Replace lone LaTeX symbols outside math blocks for name, sym in GREEK_LETTERS.items(): text = re.sub(r'\\' + name + r'\b', sym, text) for op, sym in MATH_SYMBOLS.items(): text = re.sub(r'\\' + op + r'\b', sym, text) text = re.sub(r'\\left\s*([(\[{|.])', r'\1', text) text = re.sub(r'\\right\s*([)\]}|.])', r'\1', text) # 6.5. Markdown Tables (parsed into styled HTML and stored as placeholders) def parse_markdown_tables(src_text: str) -> str: lines = src_text.split("\n") new_lines = [] i = 0 while i < len(lines): line = lines[i].strip() if "|" in line and i + 1 < len(lines): sep_line = lines[i + 1].strip() if re.match(r'^\|?(\s*:?-+:?\s*\|)+\s*(:?-+:?\s*)?\|?$', sep_line) and "-" in sep_line: def split_row(r): r_clean = r.strip() if r_clean.startswith("|"): r_clean = r_clean[1:] if r_clean.endswith("|"): r_clean = r_clean[:-1] return [c.strip() for c in r_clean.split("|")] headers = split_row(line) separators = split_row(sep_line) alignments = [] for s in separators: s = s.strip() if s.startswith(":") and s.endswith(":"): alignments.append("center") elif s.endswith(":"): alignments.append("right") else: alignments.append("left") body_rows = [] j = i + 2 while j < len(lines): row_line = lines[j].strip() if not row_line or "|" not in row_line: break body_rows.append(split_row(row_line)) j += 1 num_cols = len(headers) def format_cell(c: str) -> str: c = re.sub(r'\*\*(.*?)\*\*', r'\1', c) c = re.sub(r'__(.*?)__', r'\1', c) c = re.sub(r'(?\1', c) c = re.sub(r'`([^`]+)`', r'\1', c) return c table_html = [ '
' ] # Header table_html.append('') for idx, h in enumerate(headers): align = alignments[idx] if idx < len(alignments) else "left" cell_fmt = format_cell(h) table_html.append( f'' ) table_html.append('') # Body table_html.append('') for r_idx, row in enumerate(body_rows): bg_color = "#10131d" if r_idx % 2 == 0 else "#151a27" table_html.append(f'') for idx in range(num_cols): cell_content = row[idx] if idx < len(row) else "" align = alignments[idx] if idx < len(alignments) else "left" cell_fmt = format_cell(cell_content) table_html.append( f'' ) table_html.append('') table_html.append('
{cell_fmt}
{cell_fmt}
') new_lines.append(store_placeholder("".join(table_html))) i = j continue new_lines.append(lines[i]) i += 1 return "\n".join(new_lines) text = parse_markdown_tables(text) # 7. Standard Markdown Formats # Bold **text** (thick/heavy bold styling) text = re.sub(r'\*\*(.*?)\*\*', r'\1', text) text = re.sub(r'__(.*?)__', r'\1', text) # Italic *text* text = re.sub(r'(?\1', text) # Inline Code `code` def handle_inline_code(m): code_snip = html.escape(m.group(1)) snip_html = ( f'{code_snip}' ) return store_placeholder(snip_html) text = re.sub(r'`([^`]+)`', handle_inline_code, text) # Headers text = re.sub(r'^### (.*?)$', r'

\1

', text, flags=re.MULTILINE) text = re.sub(r'^## (.*?)$', r'

\1

', text, flags=re.MULTILINE) text = re.sub(r'^# (.*?)$', r'

\1

', text, flags=re.MULTILINE) # Lists text = re.sub(r'^\s*[-*+]\s+(.*?)$', r'
• \1
', text, flags=re.MULTILINE) text = re.sub(r'^\s*(\d+)\.\s+(.*?)$', r'
\1. \2
', text, flags=re.MULTILINE) # Line breaks text = text.replace("\n", "
") # Clean redundant br tags text = re.sub(r'(
\s*)+', r'
', text) # 8. Restore all placeholders iteratively (resolves nested placeholders such as math or code inside tables) for _ in range(6): replaced_any = False for idx, snippet in enumerate(placeholders): token = f"QQQMAGITOKEN{idx}ZZZ" if token in text: text = text.replace(token, snippet) replaced_any = True if not replaced_any: break return text