python-color-math 0.1.0__tar.gz

python_color_math-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aditya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_color_math-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: python-color-math
+Version: 0.1.0
+Summary: Pure Python semantic LaTeX and MathJax colorizer for Obsidian Markdown, KaTeX, and math notes.
+Author: 36ty-blip
+License: MIT License
+        
+        Copyright (c) 2026 Aditya
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/36ty-blip/python-color-math
+Project-URL: Repository, https://github.com/36ty-blip/python-color-math
+Project-URL: Issues, https://github.com/36ty-blip/python-color-math/issues
+Keywords: obsidian,latex,math,markdown,colorizer,katex,mathjax,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🎨 color-math (Python)
+
+> Pure Python semantic LaTeX and MathJax colorizer for Obsidian Markdown notes, KaTeX documents, and scientific workflows. Zero dependencies.
+
+[![CI](https://github.com/36ty-blip/python-color-math/actions/workflows/ci.yml/badge.svg)](https://github.com/36ty-blip/python-color-math/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-color-math.svg)](https://pypi.org/project/python-color-math/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python: 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+
+`python-color-math` is a fast, standalone command-line tool and Python library that automatically parses LaTeX and MathJax expressions and wraps elements in semantic `\textcolor{...}{...}` annotations. It works across plain Markdown, Obsidian notes, Quarto documents, Jupyter notebooks, and raw LaTeX files without modifying surrounding prose or code blocks.
+
+> [!NOTE]
+> **Looking for the Obsidian Plugin?** Check out [obsidian-color-math](https://github.com/36ty-blip/obsidian-color-math) for real-time live preview math coloring directly inside Obsidian!
+
+---
+
+## ✨ Features
+
+- **Zero External Dependencies**: Runs entirely on the Python Standard Library (Python 3.10+).
+- **Physical Units & Metric Prefixes**: Distinguishes units (`\mu m`, `m/s`, `nm`, `kg`) from variables, shielding algebraic variables like $m$ in $F = ma$ or $E = mc^2$.
+- **Calculus Differentials & Derivatives**: Recognizes infinitesimal differentials ($dx$, $dt$, $d\theta$) and derivative fractions ($\frac{d}{dx}$, $\frac{\partial \psi}{\partial t}$), while preserving standalone distance $d$ and relations like $d\iff e$.
+- **Dirac Quantum Bra-Ket Notation**: Formats kets ($|\psi\rangle$), bras ($\langle\phi|$), and expectation values ($\langle\phi|\hat{H}|\psi\rangle$) while protecting absolute values ($|x| < 5$).
+- **Dimensionless Numbers**: Identifies contiguous engineering numbers ($Re$, $Ma$, $Pr$, $Nu$) without capturing separated variables ($R\,e$).
+- **Rainbow Delimiters**: Stack-based delimiter matching that colors nested parentheses, brackets, and braces by nesting depth.
+- **Mathematical Symbol Taxonomy**: Categorizes constants ($\pi, \hbar, \infty$), Greek parameters ($\alpha, \theta, \lambda$), functions ($\sin, \cos, \ln$), and bound summation/limit indices.
+- **Variable Data-Flow Hashing**: Deterministically hashes identifiers across an equation so each unique variable maintains a consistent color across terms.
+- **Boxed Equations**: Preserves `\boxed{...}` wrappers while coloring internal mathematical structures.
+- **Signature Tokyo Night Palette**: Muted pastel tones calibrated for readability and reduced eye strain.
+- **Markdown & TeX Safety**: Fenced code blocks, inline code, TeX comments, and `\verb` blocks are protected and left unmodified.
+- **Lossless & Reversible**: Includes a `--undo` command to cleanly strip all injected colors back to original LaTeX notation.
+
+---
+
+## 🚀 Installation
+
+Install from PyPI:
+
+```bash
+pip install python-color-math
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/36ty-blip/python-color-math.git
+cd python-color-math
+pip install .
+```
+
+---
+
+## 💻 CLI Usage
+
+### Process a Markdown or LaTeX file
+
+```bash
+# Colorize equations in a single note
+color-math note.md
+
+# Colorize an entire directory of notes recursively
+color-math ./vault/
+
+# Preview changes without modifying files (Dry Run)
+color-math --dry-run note.md
+
+# Revert and clean colors back to plain LaTeX
+color-math --undo note.md
+```
+
+### Stdin / Pipe Support
+
+Pipe equations directly through the CLI:
+
+```bash
+echo "$$\frac{d}{dx}f(g(x)) = f'(g(x)) \cdot g'(x)$$" | color-math
+```
+
+---
+
+## 🐍 Python API
+
+Use `color-math` directly as a library in your Python applications, scripts, or data pipelines:
+
+```python
+from color_math import colorize_latex, ColorMathOptions
+
+latex = r"\frac{d}{dx}f(g(x)) = f'(g(x)) \cdot g'(x)"
+
+# Basic coloring with default Tokyo Night palette
+colored = colorize_latex(latex)
+print(colored)
+
+# Enable extended features (Rainbow delimiters, Variable hashing, etc.)
+opts = ColorMathOptions.all_enabled()
+extended_colored = colorize_latex(latex, options=opts)
+```
+
+---
+
+## 🧪 Testing
+
+Run the comprehensive test suites (51 tests):
+
+```bash
+# Run feature test suite
+python -m unittest discover tests
+
+# Run regression self-test suite
+python -m tests.self_test
+```
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.

python_color_math-0.1.0/README.md

@@ -0,0 +1,116 @@
+# 🎨 color-math (Python)
+
+> Pure Python semantic LaTeX and MathJax colorizer for Obsidian Markdown notes, KaTeX documents, and scientific workflows. Zero dependencies.
+
+[![CI](https://github.com/36ty-blip/python-color-math/actions/workflows/ci.yml/badge.svg)](https://github.com/36ty-blip/python-color-math/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-color-math.svg)](https://pypi.org/project/python-color-math/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python: 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/)
+
+`python-color-math` is a fast, standalone command-line tool and Python library that automatically parses LaTeX and MathJax expressions and wraps elements in semantic `\textcolor{...}{...}` annotations. It works across plain Markdown, Obsidian notes, Quarto documents, Jupyter notebooks, and raw LaTeX files without modifying surrounding prose or code blocks.
+
+> [!NOTE]
+> **Looking for the Obsidian Plugin?** Check out [obsidian-color-math](https://github.com/36ty-blip/obsidian-color-math) for real-time live preview math coloring directly inside Obsidian!
+
+---
+
+## ✨ Features
+
+- **Zero External Dependencies**: Runs entirely on the Python Standard Library (Python 3.10+).
+- **Physical Units & Metric Prefixes**: Distinguishes units (`\mu m`, `m/s`, `nm`, `kg`) from variables, shielding algebraic variables like $m$ in $F = ma$ or $E = mc^2$.
+- **Calculus Differentials & Derivatives**: Recognizes infinitesimal differentials ($dx$, $dt$, $d\theta$) and derivative fractions ($\frac{d}{dx}$, $\frac{\partial \psi}{\partial t}$), while preserving standalone distance $d$ and relations like $d\iff e$.
+- **Dirac Quantum Bra-Ket Notation**: Formats kets ($|\psi\rangle$), bras ($\langle\phi|$), and expectation values ($\langle\phi|\hat{H}|\psi\rangle$) while protecting absolute values ($|x| < 5$).
+- **Dimensionless Numbers**: Identifies contiguous engineering numbers ($Re$, $Ma$, $Pr$, $Nu$) without capturing separated variables ($R\,e$).
+- **Rainbow Delimiters**: Stack-based delimiter matching that colors nested parentheses, brackets, and braces by nesting depth.
+- **Mathematical Symbol Taxonomy**: Categorizes constants ($\pi, \hbar, \infty$), Greek parameters ($\alpha, \theta, \lambda$), functions ($\sin, \cos, \ln$), and bound summation/limit indices.
+- **Variable Data-Flow Hashing**: Deterministically hashes identifiers across an equation so each unique variable maintains a consistent color across terms.
+- **Boxed Equations**: Preserves `\boxed{...}` wrappers while coloring internal mathematical structures.
+- **Signature Tokyo Night Palette**: Muted pastel tones calibrated for readability and reduced eye strain.
+- **Markdown & TeX Safety**: Fenced code blocks, inline code, TeX comments, and `\verb` blocks are protected and left unmodified.
+- **Lossless & Reversible**: Includes a `--undo` command to cleanly strip all injected colors back to original LaTeX notation.
+
+---
+
+## 🚀 Installation
+
+Install from PyPI:
+
+```bash
+pip install python-color-math
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/36ty-blip/python-color-math.git
+cd python-color-math
+pip install .
+```
+
+---
+
+## 💻 CLI Usage
+
+### Process a Markdown or LaTeX file
+
+```bash
+# Colorize equations in a single note
+color-math note.md
+
+# Colorize an entire directory of notes recursively
+color-math ./vault/
+
+# Preview changes without modifying files (Dry Run)
+color-math --dry-run note.md
+
+# Revert and clean colors back to plain LaTeX
+color-math --undo note.md
+```
+
+### Stdin / Pipe Support
+
+Pipe equations directly through the CLI:
+
+```bash
+echo "$$\frac{d}{dx}f(g(x)) = f'(g(x)) \cdot g'(x)$$" | color-math
+```
+
+---
+
+## 🐍 Python API
+
+Use `color-math` directly as a library in your Python applications, scripts, or data pipelines:
+
+```python
+from color_math import colorize_latex, ColorMathOptions
+
+latex = r"\frac{d}{dx}f(g(x)) = f'(g(x)) \cdot g'(x)"
+
+# Basic coloring with default Tokyo Night palette
+colored = colorize_latex(latex)
+print(colored)
+
+# Enable extended features (Rainbow delimiters, Variable hashing, etc.)
+opts = ColorMathOptions.all_enabled()
+extended_colored = colorize_latex(latex, options=opts)
+```
+
+---
+
+## 🧪 Testing
+
+Run the comprehensive test suites (51 tests):
+
+```bash
+# Run feature test suite
+python -m unittest discover tests
+
+# Run regression self-test suite
+python -m tests.self_test
+```
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.

python_color_math-0.1.0/color_math/__init__.py

@@ -0,0 +1,8 @@
+"""Public helpers for converting Obsidian LaTeX color markup."""
+
+from .adapters import detect_format, transform_document
+from .config import ColorMathOptions
+from .converters.block import convert_text
+from .undo import uncolor_text
+
+__all__ = ["ColorMathOptions", "convert_text", "detect_format", "transform_document", "uncolor_text"]

python_color_math-0.1.0/color_math/__main__.py

@@ -0,0 +1,5 @@
+from .main import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

python_color_math-0.1.0/color_math/adapters.py

@@ -0,0 +1,288 @@
+"""Thin document adapters around the existing Markdown math converter."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .converters.block import convert_math_block, convert_text
+from .undo import uncolor_fragment, uncolor_text
+from .utils.latex_helpers import read_comment_end, read_verb_end
+
+
+FORMATS = ("auto", "markdown", "jupyter", "anki", "tex")
+ANKI_DELIMITERS = (
+    (r"\[", r"\]"),
+    (r"\(", r"\)"),
+    ("[$$]", "[/$$]"),
+    ("[$]", "[/$]"),
+)
+MATH_ENVIRONMENTS = {
+    "align", "align*", "alignat", "alignat*", "displaymath",
+    "equation", "equation*", "eqnarray", "eqnarray*", "flalign",
+    "flalign*", "gather", "gather*", "math", "multline", "multline*",
+}
+VERBATIM_ENVIRONMENTS = {"Verbatim", "lstlisting", "minted", "verbatim", "verbatim*"}
+BEGIN_RE = re.compile(r"\\begin\{([^{}]+)\}")
+HEX_COLOR_RE = re.compile(r"\\textcolor\{#([0-9A-Fa-f]{6})\}")
+NATIVE_COLOR_RE = re.compile(r"\\textcolor\{colormath([0-9A-Fa-f]{6})\}")
+NATIVE_BEGIN = "% color-math: begin generated xcolor support"
+NATIVE_END = "% color-math: end generated xcolor support"
+NATIVE_BLOCK_RE = re.compile(
+    rf"(?m)^{re.escape(NATIVE_BEGIN)}(?:\r?\n).*?^{re.escape(NATIVE_END)}(?:\r?\n)?",
+    re.DOTALL,
+)
+
+
+class AdapterError(ValueError):
+    """A document cannot be safely handled by its selected adapter."""
+
+
+def detect_format(path: Path | None, requested: str = "auto") -> str:
+    if requested != "auto":
+        return requested
+    if path is not None and path.suffix.lower() == ".ipynb":
+        return "jupyter"
+    if path is not None and path.suffix.lower() in {".tex", ".latex"}:
+        return "tex"
+    return "markdown"
+
+
+def transform_document(text: str, format_name: str, undo: bool = False) -> str:
+    if format_name == "markdown":
+        return uncolor_text(text) if undo else convert_text(text)
+    if format_name == "jupyter":
+        return _transform_notebook(text, undo)
+    if format_name == "anki":
+        return _transform_delimited(text, ANKI_DELIMITERS, undo)
+    if format_name == "tex":
+        return _transform_tex(text, undo)
+    raise AdapterError(f"unsupported format: {format_name}")
+
+
+def _transform_fragment(text: str, undo: bool) -> str:
+    if undo:
+        return uncolor_fragment(text)
+    converted = convert_math_block(f"$${text}$$")
+    return converted[2:-2]
+
+
+def _transform_notebook(text: str, undo: bool) -> str:
+    try:
+        notebook = json.loads(text)
+    except json.JSONDecodeError as error:
+        raise AdapterError(f"invalid Jupyter JSON at line {error.lineno}: {error.msg}") from error
+
+    if not isinstance(notebook, dict) or not isinstance(notebook.get("cells"), list):
+        raise AdapterError("Jupyter notebook must contain a cells list")
+
+    changed = False
+    for index, cell in enumerate(notebook["cells"]):
+        if not isinstance(cell, dict) or cell.get("cell_type") != "markdown":
+            continue
+        source = cell.get("source", "")
+        if isinstance(source, str):
+            joined = source
+        elif isinstance(source, list) and all(isinstance(part, str) for part in source):
+            joined = "".join(source)
+        else:
+            raise AdapterError(f"markdown cell {index + 1} has an invalid source")
+
+        converted = uncolor_text(joined) if undo else convert_text(joined)
+        if converted == joined:
+            continue
+        cell["source"] = (
+            converted
+            if isinstance(source, str)
+            else converted.splitlines(keepends=True) or ([""] if source else [])
+        )
+        changed = True
+
+    if not changed:
+        return text
+
+    indentation = re.search(r"\n([ \t]+)\"", text)
+    if indentation is None:
+        output = json.dumps(notebook, ensure_ascii=False, separators=(",", ":"))
+    else:
+        output = json.dumps(notebook, ensure_ascii=False, indent=indentation.group(1))
+    ending = "\r\n" if text.endswith("\r\n") else "\n" if text.endswith("\n") else ""
+    return output + ending
+
+
+def _is_escaped(text: str, index: int) -> bool:
+    backslashes = 0
+    index -= 1
+    while index >= 0 and text[index] == "\\":
+        backslashes += 1
+        index -= 1
+    return backslashes % 2 == 1
+
+
+def _next_delimiter(
+    text: str,
+    start: int,
+    delimiters: tuple[tuple[str, str], ...],
+) -> tuple[int, str, str] | None:
+    matches = [
+        (position, opening, closing)
+        for opening, closing in delimiters
+        if (position := _find_unescaped(text, opening, start)) >= 0
+    ]
+    return min(matches, default=None, key=lambda match: match[0])
+
+
+def _find_unescaped(text: str, token: str, start: int) -> int:
+    while (position := text.find(token, start)) >= 0:
+        if not _is_escaped(text, position):
+            return position
+        start = position + len(token)
+    return -1
+
+
+def _transform_delimited(
+    text: str,
+    delimiters: tuple[tuple[str, str], ...],
+    undo: bool,
+) -> str:
+    output: list[str] = []
+    index = 0
+    while match := _next_delimiter(text, index, delimiters):
+        start, opening, closing = match
+        end = _find_unescaped(text, closing, start + len(opening))
+        if end < 0:
+            break
+        output.append(text[index:start + len(opening)])
+        output.append(_transform_fragment(text[start + len(opening):end], undo))
+        output.append(closing)
+        index = end + len(closing)
+    output.append(text[index:])
+    return "".join(output)
+
+
+def _find_active(text: str, token: str, start: int) -> int:
+    index = start
+    while index < len(text):
+        if text[index] == "%" and not _is_escaped(text, index):
+            index = read_comment_end(text, index)
+            continue
+        if text[index] == "\\":
+            verb = read_verb_end(text, index)
+            if verb is not None:
+                index = verb[0]
+                continue
+        if text.startswith(token, index) and not _is_escaped(text, index):
+            return index
+        index += 1
+    return -1
+
+
+def _find_dollar(text: str, start: int, width: int) -> int:
+    token = "$" * width
+    index = start
+    while (index := _find_active(text, token, index)) >= 0:
+        before = index > 0 and text[index - 1] == "$"
+        after = index + width < len(text) and text[index + width] == "$"
+        if not before and not after:
+            return index
+        index += width
+    return -1
+
+
+def _transform_tex_math(text: str, undo: bool) -> str:
+    output: list[str] = []
+    index = 0
+    while index < len(text):
+        if text[index] == "%" and not _is_escaped(text, index):
+            end = read_comment_end(text, index)
+            output.append(text[index:end])
+            index = end
+            continue
+
+        if text[index] == "\\":
+            verb = read_verb_end(text, index)
+            if verb is not None:
+                end = verb[0]
+                output.append(text[index:end])
+                index = end
+                continue
+
+            environment = BEGIN_RE.match(text, index)
+            if environment is not None:
+                name = environment.group(1)
+                closing = rf"\end{{{name}}}"
+                end_start = _find_active(text, closing, environment.end())
+                if end_start >= 0 and name in VERBATIM_ENVIRONMENTS:
+                    end = end_start + len(closing)
+                    output.append(text[index:end])
+                    index = end
+                    continue
+                if end_start >= 0 and name in MATH_ENVIRONMENTS:
+                    end = end_start + len(closing)
+                    output.append(_transform_fragment(text[index:end], undo))
+                    index = end
+                    continue
+
+            pair = next(
+                ((opening, closing) for opening, closing in ((r"\[", r"\]"), (r"\(", r"\)")) if text.startswith(opening, index)),
+                None,
+            )
+            if pair is not None:
+                opening, closing = pair
+                end_start = _find_active(text, closing, index + len(opening))
+                if end_start >= 0:
+                    output.append(opening)
+                    output.append(_transform_fragment(text[index + len(opening):end_start], undo))
+                    output.append(closing)
+                    index = end_start + len(closing)
+                    continue
+
+        if text[index] == "$" and not _is_escaped(text, index):
+            width = 2 if text.startswith("$$", index) else 1
+            end_start = _find_dollar(text, index + width, width)
+            if end_start >= 0:
+                delimiter = "$" * width
+                output.append(delimiter)
+                output.append(_transform_fragment(text[index + width:end_start], undo))
+                output.append(delimiter)
+                index = end_start + width
+                continue
+
+        output.append(text[index])
+        index += 1
+    return "".join(output)
+
+
+def _native_support(text: str) -> str:
+    translated = HEX_COLOR_RE.sub(
+        lambda match: rf"\textcolor{{colormath{match.group(1).lower()}}}",
+        text,
+    )
+    colors = sorted({match.lower() for match in NATIVE_COLOR_RE.findall(translated)})
+    if not colors:
+        return translated
+
+    newline = "\r\n" if "\r\n" in translated else "\n"
+    lines = [NATIVE_BEGIN]
+    user_document = NATIVE_BLOCK_RE.sub("", translated)
+    if not re.search(r"\\usepackage(?:\[[^]]*\])?\{[^}]*\bxcolor\b[^}]*\}", user_document):
+        lines.append(r"\usepackage{xcolor}")
+    lines.extend(
+        rf"\definecolor{{colormath{color}}}{{HTML}}{{{color.upper()}}}"
+        for color in colors
+    )
+    lines.append(NATIVE_END)
+    block = newline.join(lines) + newline
+
+    if NATIVE_BLOCK_RE.search(translated):
+        return NATIVE_BLOCK_RE.sub(lambda _: block, translated, count=1)
+    document_class = re.search(r"(?m)^\\documentclass[^\r\n]*(?:\r?\n|$)", translated)
+    insertion = document_class.end() if document_class else 0
+    return translated[:insertion] + block + translated[insertion:]
+
+
+def _transform_tex(text: str, undo: bool) -> str:
+    if undo:
+        return _transform_tex_math(NATIVE_BLOCK_RE.sub("", text), True)
+    return _native_support(_transform_tex_math(text, False))