Fix markdown preview math replacement inside code blocks

app.py

@@ -178,18 +178,23 @@ def to_math_html(text: str) -> str:
         return ""
 
     blocks: dict[str, str] = {}
+    literals: dict[str, str] = {}
     counter = [0]
 
     def display_block(m):
         key = f'ZZDISPLAYMATH{counter[0]}ZZ'
         counter[0] += 1
-        blocks[key] = f'<div class="math-display">{_to_mathml(m.group(1).strip(), display=True)}</div>'
+        expr = m.group(1).strip()
+        blocks[key] = f'<div class="math-display">{_to_mathml(expr, display=True)}</div>'
+        literals[key] = f'\\[{expr}\\]'
         return f'\n\n{key}\n\n'
 
     def inline_math(m):
         key = f'ZZINLINEMATH{counter[0]}ZZ'
         counter[0] += 1
-        blocks[key] = _to_mathml(m.group(1).strip(), display=False)
+        expr = m.group(1).strip()
+        blocks[key] = _to_mathml(expr, display=False)
+        literals[key] = f'\\({expr}\\)'
         return key
 
     # Replace display math \[...\] with placeholder tokens
@@ -202,11 +207,32 @@ def to_math_html(text: str) -> str:
     # Run markdown on text that now contains only safe placeholder tokens
     html = md_lib.markdown(text, extensions=['tables', 'fenced_code', 'sane_lists'])
 
+    # Protect rendered code/pre blocks so placeholder swap never mutates literal code.
+    protected_blocks: dict[str, str] = {}
+    protected_counter = [0]
+
+    def _protect_code_html(m):
+        token = f'ZZCODEHTML{protected_counter[0]}ZZ'
+        protected_counter[0] += 1
+        protected_blocks[token] = m.group(0)
+        return token
+
+    html = re.sub(r'<pre\b[^>]*>.*?</pre>', _protect_code_html, html, flags=re.DOTALL)
+    html = re.sub(r'<code\b[^>]*>.*?</code>', _protect_code_html, html, flags=re.DOTALL)
+
     # Swap placeholders back for MathML/HTML (handle <p>KEY</p> wrapping too)
     for key, value in blocks.items():
         html = html.replace(f'<p>{key}</p>', value)
         html = html.replace(key, value)
 
+    # Restore protected literal code/pre blocks unchanged.
+    for token, original in protected_blocks.items():
+        html = html.replace(token, original)
+
+    # Placeholders left at this stage occur inside code/pre; keep them literal.
+    for key, literal in literals.items():
+        html = html.replace(key, html_lib.escape(literal))
+
     return f'<div class="math-preview">{html}</div>'
 
 def embed_images(markdown, crops):
@@ -464,4 +490,4 @@ if __name__ == "__main__":
         server_name="0.0.0.0" if local else None,
         head=PREVIEW_CSS,
         ssr_mode=False,      # SSR is experimental in Gradio 6 and breaks HF Spaces routing
-    )
+    )

tests/test_markdown_preview.py

@@ -0,0 +1,107 @@
+import ast
+import pathlib
+import re
+import html as html_lib
+import types
+import unittest
+
+
+class _FakeMarkdown:
+    @staticmethod
+    def markdown(text, extensions=None):
+        blocks = []
+        lines = text.splitlines()
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            if line.startswith("```"):
+                i += 1
+                code_lines = []
+                while i < len(lines) and not lines[i].startswith("```"):
+                    code_lines.append(lines[i])
+                    i += 1
+                if i < len(lines) and lines[i].startswith("```"):
+                    i += 1
+                code_text = "\n".join(code_lines)
+                blocks.append(f"<pre><code>{code_text}\n</code></pre>")
+                continue
+
+            if not line.strip():
+                i += 1
+                continue
+
+            para = [line]
+            i += 1
+            while i < len(lines) and lines[i].strip() and not lines[i].startswith("```"):
+                para.append(lines[i])
+                i += 1
+
+            paragraph = " ".join(para)
+            paragraph = re.sub(r"`([^`]+)`", r"<code>\1</code>", paragraph)
+            blocks.append(f"<p>{paragraph}</p>")
+
+        return "\n".join(blocks)
+
+
+class _FakeConverter:
+    @staticmethod
+    def convert(latex):
+        return f"<math>{latex}</math>"
+
+
+_FAKE_LATEX2MATHML = types.SimpleNamespace(converter=_FakeConverter())
+
+
+def _load_preview_functions():
+    app_path = pathlib.Path(__file__).resolve().parents[1] / "app.py"
+    source = app_path.read_text(encoding="utf-8")
+    module = ast.parse(source, filename=str(app_path))
+
+    wanted = {"_to_mathml", "to_math_html"}
+    fn_nodes = [n for n in module.body if isinstance(n, ast.FunctionDef) and n.name in wanted]
+    fn_nodes.sort(key=lambda n: n.lineno)
+
+    test_mod = ast.Module(body=fn_nodes, type_ignores=[])
+    code = compile(test_mod, filename=str(app_path), mode="exec")
+
+    scope = {
+        "re": re,
+        "html_lib": html_lib,
+        "md_lib": _FakeMarkdown,
+        "latex2mathml": _FAKE_LATEX2MATHML,
+    }
+    exec(code, scope)
+    return scope["to_math_html"]
+
+
+class MarkdownPreviewTests(unittest.TestCase):
+    def test_math_not_replaced_inside_code_contexts(self):
+        to_math_html = _load_preview_functions()
+
+        text = (
+            "Inline code: `\\(a+b\\)`\n\n"
+            "Normal inline math: \\(c+d\\)\n\n"
+            "```text\n"
+            "\\[x+y\\]\n"
+            "\\(m+n\\)\n"
+            "```\n"
+        )
+
+        html = to_math_html(text)
+
+        # Math outside code should still render as MathML.
+        self.assertIn("<math", html)
+
+        # Code/pre contents should stay literal LaTeX delimiters.
+        self.assertIn("<code>\\(a+b\\)</code>", html)
+        self.assertIn("<pre><code>", html)
+        self.assertIn("\\[x+y\\]", html)
+        self.assertIn("\\(m+n\\)", html)
+
+        # Internal placeholder tokens should not leak to final output.
+        self.assertNotIn("ZZINLINEMATH", html)
+        self.assertNotIn("ZZDISPLAYMATH", html)
+
+
+if __name__ == "__main__":
+    unittest.main()