PyPI - python-color-math - Versions diffs - 0.1.0__py3-none-any.whl - Mend

python-color-math 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

color_math/__init__.py +8 -0
color_math/__main__.py +5 -0
color_math/adapters.py +288 -0
color_math/config.py +351 -0
color_math/converters/__init__.py +27 -0
color_math/converters/align.py +18 -0
color_math/converters/block.py +126 -0
color_math/converters/derivative.py +266 -0
color_math/converters/equation.py +5 -0
color_math/converters/generic.py +101 -0
color_math/converters/integral.py +16 -0
color_math/converters/limit.py +16 -0
color_math/converters/matrix.py +143 -0
color_math/converters/semantic.py +76 -0
color_math/io.py +53 -0
color_math/main.py +162 -0
color_math/parsers/__init__.py +64 -0
color_math/parsers/braket.py +109 -0
color_math/parsers/delimiters.py +151 -0
color_math/parsers/differentials.py +71 -0
color_math/parsers/dimensionless.py +74 -0
color_math/parsers/latex_spans.py +1050 -0
color_math/parsers/markdown_scanner.py +463 -0
color_math/parsers/math_parser.py +366 -0
color_math/parsers/scanner.py +351 -0
color_math/parsers/taxonomy.py +124 -0
color_math/parsers/units.py +98 -0
color_math/parsers/variable_hash.py +126 -0
color_math/self_test.py +224 -0
color_math/undo.py +63 -0
color_math/utils/__init__.py +30 -0
color_math/utils/coloring.py +61 -0
color_math/utils/latex_helpers.py +232 -0
color_math/utils/spans.py +77 -0
python_color_math-0.1.0.dist-info/METADATA +167 -0
python_color_math-0.1.0.dist-info/RECORD +40 -0
python_color_math-0.1.0.dist-info/WHEEL +5 -0
python_color_math-0.1.0.dist-info/entry_points.txt +2 -0
python_color_math-0.1.0.dist-info/licenses/LICENSE +21 -0
python_color_math-0.1.0.dist-info/top_level.txt +1 -0

color_math/converters/semantic.py ADDED Viewed

@@ -0,0 +1,76 @@
+"""Small shared helpers for lossless semantic formatters."""
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+from ..config import COLORS
+from ..parsers.latex_spans import find_top_level_tokens
+from ..utils.spans import ColorSpan
+MATH_BLOCK_RE = re.compile(
+    r"^(?P<prefix>\s*(?:\#+\s*)?)\$\$(?P<body>.*)\$\$(?P<suffix>\s*)$",
+    re.DOTALL,
+)
+@dataclass(frozen=True)
+class MathBlock:
+    prefix: str
+    body: str
+    suffix: str
+    def render(self, colored_body: str) -> str:
+        return f"{self.prefix}$${colored_body}$${self.suffix}"
+def parse_math_block(source: str) -> MathBlock | None:
+    match = MATH_BLOCK_RE.fullmatch(source)
+    if match is None:
+        return None
+    return MathBlock(
+        match.group("prefix"),
+        match.group("body"),
+        match.group("suffix"),
+    )
+def trim_range(source: str, start: int, end: int) -> tuple[int, int]:
+    while start < end and source[start].isspace():
+        start += 1
+    while end > start and source[end - 1].isspace():
+        end -= 1
+    return start, end
+def first_equality(source: str) -> tuple[int, int] | None:
+    matches = find_top_level_tokens(source, ("=",))
+    return matches[0][:2] if matches else None
+def relation_spans(
+    source: str,
+    start: int = 0,
+    end: int | None = None,
+) -> list[ColorSpan]:
+    """Color only top-level structural separators."""
+    color_by_token = {
+        "=": COLORS["relation"],
+        "+": COLORS["relation"],
+        "-": COLORS["relation"],
+        r"\cdot": COLORS["dot"],
+        r"\otimes": COLORS["relation"],
+        "·": COLORS["dot"],
+        "*": COLORS["dot"],
+    }
+    return [
+        ColorSpan(start, end, color_by_token[token], priority=30)
+        for start, end, token in find_top_level_tokens(
+            source,
+            tuple(color_by_token),
+            start,
+            end,
+        )
+    ]

color_math/io.py ADDED Viewed

@@ -0,0 +1,53 @@
+from __future__ import annotations
+import codecs
+import os
+import shutil
+import tempfile
+from pathlib import Path
+def read_utf8(path: Path) -> tuple[str, bytes]:
+    """Read UTF-8 text while retaining its exact original bytes."""
+    source = path.read_bytes()
+    body = (
+        source[len(codecs.BOM_UTF8) :]
+        if source.startswith(codecs.BOM_UTF8)
+        else source
+    )
+    return body.decode("utf-8"), source
+def encode_utf8(text: str, source: bytes) -> bytes:
+    """Encode text with the source file's UTF-8 BOM convention."""
+    bom = codecs.BOM_UTF8 if source.startswith(codecs.BOM_UTF8) else b""
+    return bom + text.encode("utf-8")
+def replace_bytes(path: Path, data: bytes, source: bytes) -> bool:
+    """Atomically replace path, returning False when nothing changed."""
+    if data == source:
+        return False
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{path.name}.", suffix=".tmp", dir=path.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as stream:
+            descriptor = -1
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        if path.read_bytes() != source:
+            raise OSError("file changed while it was being processed; refusing to overwrite")
+        shutil.copymode(path, temporary)
+        os.replace(temporary, path)
+        return True
+    finally:
+        if descriptor != -1:
+            os.close(descriptor)
+        try:
+            temporary.unlink()
+        except FileNotFoundError:
+            pass

color_math/main.py ADDED Viewed

@@ -0,0 +1,162 @@
+# main.py
+#!/usr/bin/env python3
+from __future__ import annotations
+import argparse
+import sys
+from pathlib import Path
+from .adapters import AdapterError, FORMATS, detect_format, transform_document
+from .config import COLORS
+from .io import encode_utf8, read_utf8, replace_bytes
+from .parsers.math_parser import describe_math_blocks
+from .self_test import run_self_test
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Colorize LaTeX math expressions."
+    )
+    parser.add_argument(
+        "input",
+        nargs="?",
+        help=(
+            "Equation text, or file path when --file is used. "
+            "Reads stdin if omitted."
+        ),
+    )
+    parser.add_argument(
+        "-f",
+        "--file",
+        action="store_true",
+        help="Treat input as a file path and convert file contents.",
+    )
+    parser.add_argument(
+        "-i",
+        "--in-place",
+        action="store_true",
+        help="Write converted text back to file. Requires --file.",
+    )
+    parser.add_argument(
+        "--main-color",
+        default=COLORS["main"],
+        help="Override main function color.",
+    )
+    parser.add_argument(
+        "--self-test",
+        action="store_true",
+        help="Run internal tests and dependency checks.",
+    )
+    parser.add_argument(
+        "--update-generated",
+        action="store_true",
+        help="Refresh tests/generated while running --self-test.",
+    )
+    parser.add_argument(
+        "--parse",
+        action="store_true",
+        help="Inspect nested function calls without rewriting LaTeX.",
+    )
+    parser.add_argument(
+        "--undo",
+        action="store_true",
+        help="Remove LaTeX color wrappers instead of adding them.",
+    )
+    parser.add_argument(
+        "--format",
+        choices=FORMATS,
+        default="auto",
+        help=(
+            "Input format. Auto detects .ipynb and .tex files; use anki "
+            "explicitly for text/TSV exports."
+        ),
+    )
+    args = parser.parse_args()
+    # sanity check
+    if args.in_place and not args.file:
+        parser.error("--in-place requires --file")
+    if args.update_generated and not args.self_test:
+        parser.error("--update-generated requires --self-test")
+    # run tests
+    if args.self_test:
+        return run_self_test(update_generated=args.update_generated)
+    # allow runtime color override
+    COLORS["main"] = args.main_color
+    # file mode
+    if args.file:
+        if not args.input:
+            parser.error("--file requires a path")
+        path = Path(args.input)
+        try:
+            text, source = read_utf8(path)
+        except UnicodeDecodeError as error:
+            parser.exit(
+                1,
+                f"color-math: {path} is not valid UTF-8 "
+                f"(byte {error.start})\n",
+            )
+        except OSError as error:
+            parser.exit(1, f"color-math: cannot read {path}: {error}\n")
+        format_name = detect_format(path, args.format)
+        if args.parse and format_name != "markdown":
+            parser.error("--parse currently supports Markdown input only")
+        if args.parse:
+            sys.stdout.write(describe_math_blocks(text))
+            return 0
+        try:
+            converted = transform_document(text, format_name, args.undo)
+        except AdapterError as error:
+            parser.exit(1, f"color-math: {path}: {error}\n")
+        output = encode_utf8(converted, source)
+        if args.in_place:
+            try:
+                replace_bytes(path, output, source)
+            except OSError as error:
+                parser.exit(1, f"color-math: cannot replace {path}: {error}\n")
+            return 0
+        sys.stdout.buffer.write(output)
+        return 0
+    # direct input or stdin
+    text = (
+        args.input
+        if args.input is not None
+        else sys.stdin.read()
+    )
+    format_name = detect_format(None, args.format)
+    if args.parse and format_name != "markdown":
+        parser.error("--parse currently supports Markdown input only")
+    if args.parse:
+        sys.stdout.write(describe_math_blocks(text))
+        return 0
+    try:
+        sys.stdout.write(transform_document(text, format_name, args.undo))
+    except AdapterError as error:
+        parser.exit(1, f"color-math: {error}\n")
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())

color_math/parsers/__init__.py ADDED Viewed

@@ -0,0 +1,64 @@
+# parsers/__init__.py
+from .math_parser import (
+    ParsedMath,
+    SemanticSpan,
+    describe_math_blocks,
+    find_semantic_spans,
+    format_math_structure,
+    parse_math_blocks,
+    parse_math_body,
+    parser_available,
+)
+from .markdown_scanner import MarkdownScan, MarkdownSpan, scan_markdown
+from .scanner import (
+    color_latex_body_with_scanner,
+)
+from .units import UnitSpan, find_unit_spans, collect_unit_spans
+from .differentials import DifferentialSpan, find_differential_spans, collect_differential_spans
+from .braket import BraKetSpan, find_braket_spans, collect_braket_delimiter_spans
+from .dimensionless import DimensionlessSpan, find_dimensionless_spans, collect_dimensionless_spans
+from .delimiters import DelimiterPair, find_delimiter_pairs, collect_delimiter_spans
+from .taxonomy import collect_taxonomy_spans
+from .variable_hash import collect_variable_spans
+__all__ = [
+    "ParsedMath",
+    "SemanticSpan",
+    "MarkdownScan",
+    "MarkdownSpan",
+    # math_parser.py
+    "describe_math_blocks",
+    "find_semantic_spans",
+    "format_math_structure",
+    "parse_math_blocks",
+    "parse_math_body",
+    "parser_available",
+    "scan_markdown",
+    # scanner.py
+    "color_latex_body_with_scanner",
+    # new parsers
+    "UnitSpan",
+    "find_unit_spans",
+    "collect_unit_spans",
+    "DifferentialSpan",
+    "find_differential_spans",
+    "collect_differential_spans",
+    "BraKetSpan",
+    "find_braket_spans",
+    "collect_braket_delimiter_spans",
+    "DimensionlessSpan",
+    "find_dimensionless_spans",
+    "collect_dimensionless_spans",
+    "DelimiterPair",
+    "find_delimiter_pairs",
+    "collect_delimiter_spans",
+    "collect_taxonomy_spans",
+    "collect_variable_spans",
+]

color_math/parsers/braket.py ADDED Viewed

@@ -0,0 +1,109 @@
+"""Quantum Bra-Ket (Dirac) notation parser."""
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+from ..config import COLORS
+from ..utils.spans import ColorSpan
+@dataclass
+class BraKetSpan:
+    start: int
+    end: int
+    kind: str  # "bracket" | "ket" | "bra"
+def find_braket_spans(body: str) -> list[BraKetSpan]:
+    """Scans LaTeX math body to identify Quantum Bra-Ket (Dirac) notation."""
+    spans: list[BraKetSpan] = []
+    def add_span(start: int, end: int, kind: str) -> None:
+        if start >= end:
+            return
+        if not any(start < s.end and end > s.start for s in spans):
+            spans.append(BraKetSpan(start, end, kind))
+    # 1. Bracket / Expectation value: \langle ... | ... \rangle
+    braket_re = re.compile(
+        r"\\langle\s*([^<|>]+?)\s*\|\s*([^<|>]+?)(?:\s*\|\s*([^<|>]+?))?\s*\\rangle"
+    )
+    for m in braket_re.finditer(body):
+        add_span(m.start(), m.end(), "bracket")
+    # 2. Ket: | ... \rangle or \vert ... \rangle or \ket{...}
+    ket_re = re.compile(
+        r"(?:\||\\vert)\s*([^<|>]+?)\s*\\rangle|\\ket\s*\{([^}]+)\}"
+    )
+    for m in ket_re.finditer(body):
+        add_span(m.start(), m.end(), "ket")
+    # 3. Bra: \langle ... | or \langle ... \vert or \bra{...}
+    bra_re = re.compile(
+        r"\\langle\s*([^<|>]+?)\s*(?:\||\\vert)|\\bra\s*\{([^}]+)\}"
+    )
+    for m in bra_re.finditer(body):
+        add_span(m.start(), m.end(), "bra")
+    return sorted(spans, key=lambda s: s.start)
+def collect_braket_delimiter_spans(
+    body: str,
+    palette: dict[str, str] | None = None,
+    delim_color: str | None = None,
+) -> list[ColorSpan]:
+    r"""Returns color spans for Dirac delimiters (\langle, |, \rangle)."""
+    pal = palette or COLORS
+    color = delim_color or pal.get("orange", "#e0af68")
+    spans: list[ColorSpan] = []
+    # 1. \langle ... | ... \rangle
+    braket_re = re.compile(
+        r"\\langle\s*([^<|>]+?)\s*\|\s*([^<|>]+?)(?:\s*\|\s*([^<|>]+?))?\s*\\rangle"
+    )
+    for m in braket_re.finditer(body):
+        full = m.group(0)
+        langle_idx = m.start()
+        langle_end = langle_idx + len(r"\langle")
+        rangle_idx = m.start() + full.rfind(r"\rangle")
+        rangle_end = rangle_idx + len(r"\rangle")
+        spans.append(ColorSpan(langle_idx, langle_end, color, priority=25))
+        spans.append(ColorSpan(rangle_idx, rangle_end, color, priority=25))
+        bar_search = m.start()
+        while True:
+            bar_search = body.find("|", bar_search)
+            if bar_search == -1 or bar_search >= rangle_idx:
+                break
+            spans.append(ColorSpan(bar_search, bar_search + 1, color, priority=25))
+            bar_search += 1
+    # 2. Ket: | ... \rangle or \vert ... \rangle
+    ket_re = re.compile(r"(?:\||\\vert)\s*([^<|>]+?)\s*\\rangle")
+    for m in ket_re.finditer(body):
+        full = m.group(0)
+        bar_idx = m.start()
+        bar_end = bar_idx + (5 if full.startswith(r"\vert") else 1)
+        rangle_idx = m.start() + full.rfind(r"\rangle")
+        rangle_end = rangle_idx + 7
+        if not any(s.start == bar_idx for s in spans):
+            spans.append(ColorSpan(bar_idx, bar_end, color, priority=25))
+            spans.append(ColorSpan(rangle_idx, rangle_end, color, priority=25))
+    # 3. Bra: \langle ... | or \langle ... \vert
+    bra_re = re.compile(r"\\langle\s*([^<|>]+?)\s*(?:\||\\vert)")
+    for m in bra_re.finditer(body):
+        full = m.group(0)
+        langle_idx = m.start()
+        langle_end = langle_idx + 7
+        bar_idx = m.start() + max(full.rfind("|"), full.rfind(r"\vert"))
+        bar_end = bar_idx + (5 if full.endswith(r"\vert") else 1)
+        if not any(s.start == langle_idx for s in spans):
+            spans.append(ColorSpan(langle_idx, langle_end, color, priority=25))
+            spans.append(ColorSpan(bar_idx, bar_end, color, priority=25))
+    return sorted(spans, key=lambda s: s.start)

color_math/parsers/delimiters.py ADDED Viewed

@@ -0,0 +1,151 @@
+"""Rainbow delimiters parser for balanced parentheses, brackets, and braces."""
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+from ..config import RAINBOW_DELIMITER_COLORS
+from ..utils.spans import ColorSpan
+@dataclass
+class DelimiterItem:
+    delim_type: str
+    start: int
+    end: int
+    is_left_right: bool
+@dataclass
+class DelimiterPair:
+    open_item: DelimiterItem
+    close_item: DelimiterItem
+    depth: int
+def skip_whitespace(text: str, start: int) -> int:
+    while start < len(text) and text[start].isspace():
+        start += 1
+    return start
+def skip_comment(text: str, start: int) -> int:
+    idx = start + 1
+    while idx < len(text) and text[idx] not in ("\r", "\n"):
+        idx += 1
+    if idx < len(text) and text[idx] == "\r" and idx + 1 < len(text) and text[idx + 1] == "\n":
+        return idx + 2
+    return min(idx + 1, len(text))
+def get_delimiter_type(delim: str) -> str:
+    if delim in ("(", ")"):
+        return "paren"
+    if delim in ("[", "]"):
+        return "bracket"
+    if delim in (r"\{", r"\}"):
+        return "brace"
+    if delim in (r"\langle", r"\rangle"):
+        return "angle"
+    if delim in ("|", r"\|"):
+        return "pipe"
+    return "other"
+def find_delimiter_pairs(text: str) -> list[DelimiterPair]:
+    """Parses all balanced delimiter pairs in a LaTeX string."""
+    pairs: list[DelimiterPair] = []
+    stack: list[tuple[DelimiterItem, int]] = []
+    idx = 0
+    while idx < len(text):
+        if text[idx] == "%":
+            idx = skip_comment(text, idx)
+            continue
+        # Check \left / \right
+        if text.startswith(r"\left", idx):
+            after_left = skip_whitespace(text, idx + 5)
+            m = re.match(r"^(\(|\)|\[|\]|\\\{|\\\}|\\langle|\\rangle|\||\\\||\.)", text[after_left:])
+            if m:
+                delim_str = m.group(1)
+                delim_end = after_left + len(delim_str)
+                dtype = get_delimiter_type(delim_str)
+                depth = len(stack)
+                item = DelimiterItem(dtype, idx, delim_end, is_left_right=True)
+                stack.append((item, depth))
+                idx = delim_end
+                continue
+        if text.startswith(r"\right", idx):
+            after_right = skip_whitespace(text, idx + 6)
+            m = re.match(r"^(\(|\)|\[|\]|\\\{|\\\}|\\langle|\\rangle|\||\\\||\.)", text[after_right:])
+            if m:
+                delim_str = m.group(1)
+                delim_end = after_right + len(delim_str)
+                dtype = get_delimiter_type(delim_str)
+                match_idx = -1
+                for i in range(len(stack) - 1, -1, -1):
+                    if stack[i][0].is_left_right:
+                        match_idx = i
+                        break
+                if match_idx != -1:
+                    matched, matched_depth = stack.pop(match_idx)
+                    close_item = DelimiterItem(dtype, idx, delim_end, is_left_right=True)
+                    pairs.append(DelimiterPair(matched, close_item, matched_depth))
+                idx = delim_end
+                continue
+        # Regular bare delimiters
+        ch = text[idx]
+        if ch in ("(", "[") or text.startswith(r"\{", idx):
+            is_brace = text.startswith(r"\{", idx)
+            delim_str = r"\{" if is_brace else ch
+            delim_end = idx + (2 if is_brace else 1)
+            dtype = get_delimiter_type(delim_str)
+            depth = len(stack)
+            item = DelimiterItem(dtype, idx, delim_end, is_left_right=False)
+            stack.append((item, depth))
+            idx = delim_end
+            continue
+        if ch in (")", "]") or text.startswith(r"\}", idx):
+            is_brace = text.startswith(r"\}", idx)
+            delim_str = r"\}" if is_brace else ch
+            delim_end = idx + (2 if is_brace else 1)
+            dtype = get_delimiter_type(delim_str)
+            match_idx = -1
+            for i in range(len(stack) - 1, -1, -1):
+                if not stack[i][0].is_left_right and stack[i][0].delim_type == dtype:
+                    match_idx = i
+                    break
+            if match_idx != -1:
+                matched, matched_depth = stack.pop(match_idx)
+                close_item = DelimiterItem(dtype, idx, delim_end, is_left_right=False)
+                pairs.append(DelimiterPair(matched, close_item, matched_depth))
+            idx = delim_end
+            continue
+        idx += 1
+    return pairs
+def collect_delimiter_spans(
+    body: str,
+    palette: list[str] | None = None,
+) -> list[ColorSpan]:
+    """Returns color spans for rainbow delimiters colored by nesting depth."""
+    colors = palette or RAINBOW_DELIMITER_COLORS
+    pairs = find_delimiter_pairs(body)
+    spans: list[ColorSpan] = []
+    for pair in pairs:
+        color = colors[pair.depth % len(colors)]
+        spans.append(ColorSpan(pair.open_item.start, pair.open_item.end, color, priority=22))
+        spans.append(ColorSpan(pair.close_item.start, pair.close_item.end, color, priority=22))
+    return spans

color_math/parsers/differentials.py ADDED Viewed

@@ -0,0 +1,71 @@
+"""Calculus differentials and derivative operators disambiguation."""
+from __future__ import annotations
+from dataclasses import dataclass
+import re
+from ..config import COLORS
+from ..utils.spans import ColorSpan
+@dataclass
+class DifferentialSpan:
+    start: int
+    end: int
+    text: str
+    kind: str  # "differential" | "derivative_fraction"
+GREEK_LETTERS = (
+    r"alpha|beta|gamma|delta|epsilon|varepsilon|zeta|eta|theta|vartheta|iota|kappa|"
+    r"lambda|mu|nu|xi|pi|varpi|rho|varrho|sigma|varsigma|tau|upsilon|phi|varphi|chi|psi|omega|"
+    r"Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega"
+)
+DIFF_VAR = r"(?:\\(?:" + GREEK_LETTERS + r")|[a-zA-Z])"
+def find_differential_spans(body: str) -> list[DifferentialSpan]:
+    """Scans LaTeX math body to identify infinitesimal differentials and derivative operators."""
+    spans: list[DifferentialSpan] = []
+    def add_span(start: int, end: int, text: str, kind: str) -> None:
+        if start >= end:
+            return
+        if not any(start < s.end and end > s.start for s in spans):
+            spans.append(DifferentialSpan(start, end, text, kind))
+    # 1. Derivative fractions: \frac{d}{dx}, \frac{df}{dx}, \frac{\partial \psi}{\partial t}, \frac{d^2 y}{dx^2}
+    deriv_frac_re = re.compile(
+        r"\\frac\s*\{\s*(?:d|\\partial|\\mathrm\{d\})(?:\^\{?\d+\}?)?\s*(?:" + DIFF_VAR + r")?\s*\}\s*\{\s*(?:d|\\partial|\\mathrm\{d\})\s*" + DIFF_VAR + r"(?:\^\{?\d+\}?)?(?:\s*(?:d|\\partial|\\mathrm\{d\})\s*" + DIFF_VAR + r")*\s*\}"
+    )
+    for m in deriv_frac_re.finditer(body):
+        add_span(m.start(), m.end(), m.group(0), "derivative_fraction")
+    # 2. Infinitesimal differentials: dx, dt, dy, dz, dr, d\theta, d\phi, \partial x, \partial t
+    diff_re = re.compile(
+        r"(?:^|[\s+\-=*({]|\[|\\,|\\:|\\;|\\quad|\\qquad|~)(\s*(?:d|\\partial|\\mathrm\{d\}|\\delta)\s*" + DIFF_VAR + r"(?![a-zA-Z0-9_({])(?:\^\{?\d+\}?)?)"
+    )
+    for m in diff_re.finditer(body):
+        full_match = m.group(0)
+        diff_group = m.group(1)
+        diff_start = m.start() + (len(full_match) - len(diff_group))
+        d_match = re.search(r"(?:d|\\partial|\\mathrm\{d\}|\\delta)", diff_group)
+        if d_match:
+            d_offset = d_match.start()
+            actual_start = diff_start + d_offset
+            diff_text = diff_group[d_offset:]
+            diff_end = actual_start + len(diff_text)
+            add_span(actual_start, diff_end, diff_text, "differential")
+    return sorted(spans, key=lambda s: s.start)
+def collect_differential_spans(
+    body: str,
+    palette: dict[str, str] | None = None,
+    diff_spans: list[DifferentialSpan] | None = None,
+) -> list[ColorSpan]:
+    """Returns color spans for differentials and derivative operators using palette.derivative."""
+    pal = palette or COLORS
+    diffs = diff_spans if diff_spans is not None else find_differential_spans(body)
+    deriv_color = pal.get("derivative", "#bb9af7")
+    return [ColorSpan(d.start, d.end, deriv_color, priority=24) for d in diffs]