python-color-math 0.2.2__py3-none-any.whl → 0.2.13__py3-none-any.whl

color_math/__init__.py

@@ -5,13 +5,19 @@ from .config import ColorMathOptions
 from .converters.block import convert_text
 from .undo import uncolor_text
 
-__version__ = "0.2.2"
+from .ipython import ColorMath, colormath, load_ipython_extension, unload_ipython_extension
+
+__version__ = "0.2.13"
 
 __all__ = [
     "__version__",
+    "ColorMath",
     "ColorMathOptions",
+    "colormath",
     "convert_text",
     "detect_format",
+    "load_ipython_extension",
     "transform_document",
     "uncolor_text",
+    "unload_ipython_extension",
 ]

color_math/adapters.py

@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
+import copy
 import json
 import re
 from pathlib import Path
 
 from .config import ColorMathOptions
 from .converters.block import convert_math_block, convert_text
+from .parsers.frontmatter import detect_note_field
 from .undo import uncolor_fragment, uncolor_text
 from .utils.latex_helpers import read_comment_end, read_verb_end
 
@@ -50,6 +52,19 @@ def detect_format(path: Path | None, requested: str = "auto") -> str:
     return "markdown"
 
 
+def has_potential_math(text: str, format_name: str = "auto") -> bool:
+    """Ultra-fast probe to bypass documents that cannot possibly contain math."""
+    if "$" in text:
+        return True
+    if r"\[" in text or r"\(" in text:
+        return True
+    if format_name in ("tex", "auto") and r"\begin{" in text:
+        return True
+    if format_name in ("anki", "auto") and ("[$]" in text or "[$$]" in text):
+        return True
+    return False
+
+
 def transform_document(
     text: str,
     format_name: str,
@@ -57,10 +72,28 @@ def transform_document(
     palette: dict[str, str] | None = None,
     options: ColorMathOptions | None = None,
 ) -> str:
-    if format_name == "markdown":
-        return uncolor_text(text) if undo else convert_text(text, palette=palette, options=options)
     if format_name == "jupyter":
         return _transform_notebook(text, undo, palette=palette, options=options)
+
+    if undo:
+        if r"\textcolor" not in text:
+            return text
+    elif not has_potential_math(text, format_name):
+        return text
+
+    if format_name == "markdown":
+        if undo:
+            return uncolor_text(text)
+        opts = options
+        detection = detect_note_field(text)
+        if detection.is_quantum:
+            if opts is None:
+                opts = ColorMathOptions(color_quantum_operators=True, field="quantum")
+            else:
+                opts = copy.copy(opts)
+                opts.color_quantum_operators = True
+                opts.field = "quantum"
+        return convert_text(text, palette=palette, options=opts)
     if format_name == "anki":
         return _transform_delimited(text, ANKI_DELIMITERS, undo, palette=palette, options=options)
     if format_name == "tex":

color_math/colormath.default.json

@@ -0,0 +1,57 @@
+{
+  "_comment": "Python Color Math factory default configuration. This file serves as an immutable reference. To customize settings, edit '.colormath.json'. If '.colormath.json' has syntax errors or missing keys, Color Math safely falls back to these defaults.",
+  "theme": "default",
+  "colors": {
+    "main": "#7aa2f7",
+    "orange": "#e0af68",
+    "dot": "white",
+    "derivative": "#bb9af7",
+    "chain": "#9ece6a",
+    "upper": "#bb9af7",
+    "relation": "white",
+    "arrow": "#f7768e",
+    "set": "#bb9af7",
+    "spacing": "white",
+    "parameter": "#bb9af7",
+    "unit": "#73daca"
+  },
+  "options": {
+    "enable_taxonomy": true,
+    "rainbow_delimiters": true,
+    "variable_data_flow": false,
+    "color_units": true,
+    "color_differentials": true,
+    "color_braket": true,
+    "color_dimensionless": true,
+    "rainbow_bare_braces": false,
+    "highlight_unmatched_braces": false
+  },
+  "unicode": {
+    "greek_style": "plane1",
+    "convert_definite_integrals": false,
+    "convert_bounded_operators": false,
+    "convert_prose_to_unicode": false,
+    "convert_prose_to_latex": false
+  },
+  "_role_descriptions": {
+    "main": "Primary functions, terms, and outermost operations (e.g. f(x))",
+    "derivative": "Derivative marks and differentiated functions (e.g. f'(x))",
+    "chain": "Chain rule factors, inner differential stages (e.g. g'(x), y')",
+    "orange": "Big operators, sums, integrals, and limits (e.g. \\sum, \\int, \\lim)",
+    "dot": "Multiplication symbols, dots, and cross products (e.g. \\cdot, \\times)",
+    "relation": "Equals, inequalities, and comparison symbols (e.g. =, <, \\le)",
+    "arrow": "Implication and mapping arrows (e.g. \\to, \\implies)",
+    "set": "Set theory relations and operators (e.g. \\in, \\subset)",
+    "spacing": "LaTeX spacing and alignment commands (e.g. \\quad, \\,)",
+    "upper": "Matrix exponents, transposes, and top indices (e.g. A^T, M^{-1})",
+    "parameter": "Inner function parameters and indexed variables",
+    "unit": "Physical units and dimensions (e.g. m/s, \\mu m, ^\\circ C)"
+  },
+  "_unicode_descriptions": {
+    "greek_style": "Greek letter typography: 'plane1' (Mathematical Italic: 𝝍, 𝝰) or 'standard' (ψ, α)",
+    "convert_definite_integrals": "Convert bounded integrals like \\int_a^b to ∫_a^b (default: false to preserve vertical TeX limits)",
+    "convert_bounded_operators": "Convert bounded summations/products like \\sum_{i=1}^n to ∑_{i=1}^n (default: false)",
+    "convert_prose_to_unicode": "Convert LaTeX commands like \\psi to 𝜓 in regular prose outside math blocks (default: false to protect prose)",
+    "convert_prose_to_latex": "Convert Unicode symbols like 𝝍 back to \\psi in regular prose outside math blocks (default: false)"
+  }
+}

color_math/config.py

@@ -18,6 +18,7 @@ DEFAULT_COLORS = {
     "spacing": "white",
     "parameter": "#bb9af7",
     "unit": "#73daca",
+    "energy_operator": "#2ac3de",
 }
 
 THEMES: dict[str, dict[str, str]] = {
@@ -84,6 +85,39 @@ ROLE_DESCRIPTIONS: dict[str, str] = {
 COLORS = dict(DEFAULT_COLORS)
 
 
+from .unicode import (
+    UNICODE_BIG_OPERATORS,
+    UNICODE_INTEGRALS,
+    UNICODE_RELATIONS,
+    UNICODE_ARROWS,
+    UNICODE_SETS,
+    UNICODE_MULTIPLICATION,
+    UNICODE_CONSTANTS,
+    UNICODE_VECTORS,
+    UNICODE_GREEK_LOWER_STANDARD,
+    UNICODE_GREEK_LOWER_PLANE1,
+    UNICODE_GREEK_UPPER_STANDARD,
+    UNICODE_GREEK_UPPER_PLANE1,
+)
+from .custom_definitions import (
+    CUSTOM_CONSTANTS,
+    CUSTOM_FUNCTIONS,
+    CUSTOM_OPERATORS,
+    CUSTOM_PARAMETERS,
+    CUSTOM_QUANTUM_OPERATORS,
+    CUSTOM_RELATIONS,
+    sanitize_definition,
+)
+
+CUSTOM_BARE_FUNCTIONS: set[str] = set()
+CUSTOM_MACRO_FUNCTIONS: set[str] = set()
+for _raw_fn in CUSTOM_FUNCTIONS:
+    _macro, _bare = sanitize_definition(_raw_fn)
+    if _bare:
+        CUSTOM_BARE_FUNCTIONS.add(_bare)
+    if _macro:
+        CUSTOM_MACRO_FUNCTIONS.add(_macro)
+
 BIG_OPERATORS = {
     r"\sum",
     r"\prod",
@@ -95,6 +129,8 @@ BIG_OPERATORS = {
     r"\bigwedge",
     r"\bigoplus",
     r"\bigotimes",
+    *UNICODE_BIG_OPERATORS.values(),
+    *CUSTOM_OPERATORS,
 }
 
 
@@ -103,6 +139,7 @@ INTEGRALS = {
     r"\iint",
     r"\iiint",
     r"\oint",
+    *UNICODE_INTEGRALS.values(),
 }
 
 
@@ -138,6 +175,8 @@ RELATIONS = {
     "=",
     "<",
     ">",
+    *UNICODE_RELATIONS.values(),
+    *CUSTOM_RELATIONS,
 }
 
 
@@ -160,6 +199,7 @@ ARROWS = {
     r"\Leftrightarrow",
     r"\mapsto",
     r"\to",
+    *UNICODE_ARROWS.values(),
 }
 
 
@@ -182,6 +222,7 @@ SET_SYMBOLS = {
     r"\in",
     r"\cup",
     r"\cap",
+    *UNICODE_SETS.values(),
 }
 
 
@@ -199,6 +240,8 @@ MULTIPLICATION_SYMBOLS = {
     r"\times",
     "·",
     "*",
+    "×",
+    "✕",
 }
 
 
@@ -216,6 +259,7 @@ FUNCTION_COMMANDS = {
     r"\sinh",
     r"\tan",
     r"\tanh",
+    *CUSTOM_MACRO_FUNCTIONS,
 }
 
 
@@ -229,6 +273,7 @@ COLOR_COMMANDS = (
     | SET_SYMBOLS
     | SPACING_COMMANDS
     | MULTIPLICATION_SYMBOLS
+    | set(CUSTOM_QUANTUM_OPERATORS)
 )
 
 
@@ -256,6 +301,8 @@ MATH_CONSTANTS = {
     r"\mathrm{e}",
     r"\mathrm{i}",
     r"\mathrm{j}",
+    *UNICODE_CONSTANTS.values(),
+    *CUSTOM_CONSTANTS,
 }
 
 
@@ -377,14 +424,13 @@ EXTENDED_BARE_FUNCTIONS = frozenset({
 })
 
 FULL_BARE_FUNCTIONS = STANDARD_BARE_FUNCTIONS | EXTENDED_BARE_FUNCTIONS
-ALL_BARE_FUNCTIONS = FULL_BARE_FUNCTIONS
-BARE_FUNCTIONS = FULL_BARE_FUNCTIONS
+ALL_BARE_FUNCTIONS = FULL_BARE_FUNCTIONS | CUSTOM_BARE_FUNCTIONS
+BARE_FUNCTIONS = ALL_BARE_FUNCTIONS
 
 
 def get_bare_functions(options: ColorMathOptions | None = None) -> frozenset[str]:
-    if options is not None and not options.extended_functions:
-        return STANDARD_BARE_FUNCTIONS
-    return FULL_BARE_FUNCTIONS
+    base = FULL_BARE_FUNCTIONS if (options is None or options.extended_functions) else STANDARD_BARE_FUNCTIONS
+    return frozenset(base | CUSTOM_BARE_FUNCTIONS)
 
 
 MATH_ACCENTS = {
@@ -445,8 +491,18 @@ MATH_PARAMETERS = {
     r"\Phi",
     r"\Psi",
     r"\Omega",
+    *UNICODE_GREEK_LOWER_STANDARD.values(),
+    *UNICODE_GREEK_LOWER_PLANE1.values(),
+    *UNICODE_GREEK_UPPER_STANDARD.values(),
+    *UNICODE_GREEK_UPPER_PLANE1.values(),
+    "𝜓",
+    "𝝍",
+    *CUSTOM_PARAMETERS,
 }
 
+NON_SLASH_MATH_CONSTANTS = {c for c in MATH_CONSTANTS if not c.startswith("\\")}
+NON_SLASH_MATH_PARAMETERS = {c for c in MATH_PARAMETERS if not c.startswith("\\")}
+
 
 MATH_FUNCTIONS = {
     r"\sin",
@@ -541,6 +597,7 @@ MATH_FUNCTIONS = {
     r"\dn",
     r"\avg",
     r"\len",
+    *CUSTOM_MACRO_FUNCTIONS,
 }
 
 
@@ -588,6 +645,10 @@ class ColorMathOptions:
     color_single_constants: bool = False
     normalize_braces: bool = False
     extended_functions: bool = True
+    color_quantum_operators: bool = False
+    rainbow_bare_braces: bool = False
+    highlight_unmatched_braces: bool = False
+    field: str = "math"
 
     @classmethod
     def extended(cls) -> ColorMathOptions:
@@ -604,6 +665,8 @@ class ColorMathOptions:
             color_single_constants=True,
             normalize_braces=False,
             extended_functions=True,
+            rainbow_bare_braces=False,
+            highlight_unmatched_braces=True,
         )
 
     @classmethod
@@ -621,6 +684,8 @@ class ColorMathOptions:
             color_single_constants=True,
             normalize_braces=False,
             extended_functions=True,
+            rainbow_bare_braces=True,
+            highlight_unmatched_braces=True,
         )
 
 
@@ -665,11 +730,51 @@ def get_global_config_path() -> Path | None:
     return None
 
 
-def load_config(path: Path | None = None) -> tuple[dict[str, str], ColorMathOptions]:
+DEFAULT_UNICODE_CONFIG: dict[str, object] = {
+    "greek_style": "plane1",
+    "convert_definite_integrals": False,
+    "convert_bounded_operators": False,
+    "convert_prose_to_unicode": False,
+    "convert_prose_to_latex": False,
+}
+
+
+def get_bundled_default_config_path() -> Path:
+    """Return path to bundled colormath.default.json."""
+    return Path(__file__).parent / "colormath.default.json"
+
+
+def get_bundled_default_config() -> dict[str, object]:
+    """Load the factory defaults configuration object."""
+    default_path = get_bundled_default_config_path()
+    if default_path.exists():
+        try:
+            return json.loads(default_path.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    return {
+        "_comment": "Python Color Math factory default configuration",
+        "theme": "default",
+        "colors": dict(DEFAULT_COLORS),
+        "options": asdict(ColorMathOptions()),
+        "unicode": dict(DEFAULT_UNICODE_CONFIG),
+        "_role_descriptions": ROLE_DESCRIPTIONS,
+    }
+
+
+def load_config(
+    path: Path | None = None,
+) -> tuple[dict[str, str], ColorMathOptions, dict[str, object]]:
     """
     Load configuration from path, local '.colormath.json', or global user config.
-    Returns (palette_dict, ColorMathOptions).
+    Fault-tolerant: If the user file contains JSON syntax errors or invalid types,
+    a warning is emitted and it safely falls back to factory defaults without crashing.
+    Returns (palette_dict, ColorMathOptions, unicode_config_dict).
     """
+    palette = dict(DEFAULT_COLORS)
+    options = ColorMathOptions()
+    unicode_config = dict(DEFAULT_UNICODE_CONFIG)
+
     target = path
     if target is None:
         local_candidate = Path(".colormath.json")
@@ -681,48 +786,87 @@ def load_config(path: Path | None = None) -> tuple[dict[str, str], ColorMathOpti
                 target = global_candidate
 
     if target is None or not target.exists():
-        return dict(DEFAULT_COLORS), ColorMathOptions()
+        return palette, options, unicode_config
 
     try:
         data = json.loads(target.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            sys.stderr.write(
+                f"color-math warning: config file '{target}' must contain a JSON object. "
+                "Safely falling back to default configuration.\n"
+            )
+            return palette, options, unicode_config
     except Exception as err:
-        raise ValueError(f"Failed to parse config file {target}: {err}") from err
+        sys.stderr.write(
+            f"color-math warning: failed to parse config file '{target}': {err}. "
+            "Safely falling back to default configuration.\n"
+        )
+        return palette, options, unicode_config
+
+    # 1. Apply theme
+    if "theme" in data and isinstance(data["theme"], str):
+        try:
+            palette.update(get_theme(data["theme"]))
+        except ValueError:
+            pass
+
+    # 2. Apply color overrides
+    if "colors" in data and isinstance(data["colors"], dict):
+        for k, v in data["colors"].items():
+            if isinstance(k, str) and isinstance(v, str) and k in DEFAULT_COLORS:
+                palette[k] = v
+
+    # 3. Apply engine options
+    if "options" in data and isinstance(data["options"], dict):
+        raw_options = data["options"]
+        options = ColorMathOptions(
+            enable_taxonomy=bool(raw_options.get("enable_taxonomy", options.enable_taxonomy)),
+            rainbow_delimiters=bool(raw_options.get("rainbow_delimiters", options.rainbow_delimiters)),
+            variable_data_flow=bool(raw_options.get("variable_data_flow", options.variable_data_flow)),
+            color_units=bool(raw_options.get("color_units", options.color_units)),
+            color_differentials=bool(raw_options.get("color_differentials", options.color_differentials)),
+            color_braket=bool(raw_options.get("color_braket", options.color_braket)),
+            color_dimensionless=bool(raw_options.get("color_dimensionless", options.color_dimensionless)),
+            color_alignment=bool(raw_options.get("color_alignment", options.color_alignment)),
+            color_single_constants=bool(raw_options.get("color_single_constants", options.color_single_constants)),
+            normalize_braces=bool(raw_options.get("normalize_braces", options.normalize_braces)),
+            extended_functions=bool(raw_options.get("extended_functions", options.extended_functions)),
+            color_quantum_operators=bool(raw_options.get("color_quantum_operators", options.color_quantum_operators)),
+            rainbow_bare_braces=bool(raw_options.get("rainbow_bare_braces", options.rainbow_bare_braces)),
+            highlight_unmatched_braces=bool(raw_options.get("highlight_unmatched_braces", options.highlight_unmatched_braces)),
+            field=str(raw_options.get("field", options.field)),
+        )
 
-    palette = dict(DEFAULT_COLORS)
-    if isinstance(data, dict):
-        if "theme" in data and isinstance(data["theme"], str):
-            try:
-                palette.update(get_theme(data["theme"]))
-            except ValueError:
-                pass
-        if "colors" in data and isinstance(data["colors"], dict):
-            for k, v in data["colors"].items():
-                if isinstance(k, str) and isinstance(v, str):
-                    palette[k] = v
-
-    raw_options = data.get("options", {}) if isinstance(data, dict) else {}
-    options = ColorMathOptions(
-        enable_taxonomy=bool(raw_options.get("enable_taxonomy", False)),
-        rainbow_delimiters=bool(raw_options.get("rainbow_delimiters", False)),
-        variable_data_flow=bool(raw_options.get("variable_data_flow", False)),
-        color_units=bool(raw_options.get("color_units", False)),
-        color_differentials=bool(raw_options.get("color_differentials", False)),
-        color_braket=bool(raw_options.get("color_braket", False)),
-        color_dimensionless=bool(raw_options.get("color_dimensionless", False)),
-    )
-    return palette, options
+    # 4. Apply unicode options
+    if "unicode" in data and isinstance(data["unicode"], dict):
+        raw_unicode = data["unicode"]
+        if "greek_style" in raw_unicode and raw_unicode["greek_style"] in ("plane1", "standard"):
+            unicode_config["greek_style"] = raw_unicode["greek_style"]
+        if "convert_definite_integrals" in raw_unicode:
+            unicode_config["convert_definite_integrals"] = bool(raw_unicode["convert_definite_integrals"])
+        if "convert_bounded_operators" in raw_unicode:
+            unicode_config["convert_bounded_operators"] = bool(raw_unicode["convert_bounded_operators"])
+        if "convert_prose_to_unicode" in raw_unicode:
+            unicode_config["convert_prose_to_unicode"] = bool(raw_unicode["convert_prose_to_unicode"])
+        if "convert_prose_to_latex" in raw_unicode:
+            unicode_config["convert_prose_to_latex"] = bool(raw_unicode["convert_prose_to_latex"])
+
+    return palette, options, unicode_config
 
 
 def save_default_config(path: Path) -> Path:
-    """Save the clean default configuration to path."""
-    content = {
-        "_comment": "Python Color Math configuration file",
-        "theme": "default",
-        "colors": dict(DEFAULT_COLORS),
-        "options": asdict(ColorMathOptions()),
-        "_role_descriptions": ROLE_DESCRIPTIONS,
-    }
+    """Save the clean default configuration to path, and copy the reference default file."""
+    content = get_bundled_default_config()
     path.write_text(json.dumps(content, indent=2), encoding="utf-8")
+
+    # Also save .colormath.default.json alongside .colormath.json if appropriate
+    target_dir = path.parent
+    default_ref_path = target_dir / ".colormath.default.json"
+    try:
+        default_ref_path.write_text(json.dumps(content, indent=2), encoding="utf-8")
+    except OSError:
+        pass
+
     return path
 
 

color_math/converters/block.py

@@ -55,6 +55,8 @@ def _has_semantic_options(options: ColorMathOptions | None) -> bool:
             or options.color_differentials
             or options.color_braket
             or options.color_dimensionless
+            or options.color_quantum_operators
+            or options.field in ("quantum", "physics")
         )
     )
 
@@ -133,6 +135,9 @@ def convert_text(
       - inline $ ... $ math expressions
       - normal text passthrough
     """
+    if "$" not in text:
+        return text
+
     scan = scan_markdown(text)
     all_spans = sorted(
         [*scan.math_blocks, *scan.math_inlines],

color_math/converters/derivative.py

@@ -25,10 +25,10 @@ NUMERIC_FRACTION_RE = re.compile(
 )
 PLAIN_COEFFICIENT_RE = re.compile(r"[A-Za-z]")
 ADDITIVE_SEPARATOR_RE = re.compile(
-    r"[+\-=<>]|\\(?:pm|mp|leq|geq|neq|approx|sim|equiv)(?![A-Za-z])"
+    r"[+\-=<>]|\\(?:pm|mp|leq|geq|neq|approx|sim|equiv)(?![A-Za-z])|[±∓≤≥≠≈∼≡]"
 )
 MULTIPLICATIVE_GAP_RE = re.compile(
-    r"(?:\s|[·*]|\\(?:cdot|times|,|:|;|!|quad|qquad)(?![A-Za-z]))*"
+    r"(?:\s|[·*×✕]|\\(?:cdot|times|,|:|;|!|quad|qquad)(?![A-Za-z]))*"
 )
 
 
@@ -39,12 +39,25 @@ def _compact(value: str) -> str:
 def _is_derivative_prefix(value: str) -> bool:
     compact = _compact(value)
     return compact.startswith(
-        (r"\frac{d}{d", r"\dfrac{d}{d", r"\tfrac{d}{d")
+        (
+            r"\frac{d}{d",
+            r"\dfrac{d}{d",
+            r"\tfrac{d}{d",
+            r"\frac{\mathrm{d}}{\mathrm{d",
+            r"\dfrac{\mathrm{d}}{\mathrm{d",
+            r"\tfrac{\mathrm{d}}{\mathrm{d",
+            r"\frac{\partial}{\partial",
+            r"\dfrac{\partial}{\partial",
+            r"\tfrac{\partial}{\partial",
+            r"\frac{∂}{∂",
+            r"\dfrac{∂}{∂",
+            r"\tfrac{∂}{∂",
+        )
     )
 
 
 def _is_prime(value: str) -> bool:
-    return bool(re.match(r"(?:[A-Za-z]|\\[A-Za-z]+)'", value.lstrip()))
+    return bool(re.match(r"(?:[A-Za-z]|\\[A-Za-z]+|[\u0370-\u03FF\U0001D400-\U0001D7FF])'", value.lstrip()))
 
 
 def _is_numeric(value: str) -> bool:
@@ -227,6 +240,10 @@ def convert_derivative_line(source: str) -> str | None:
     if block is None:
         return None
 
+    # Delegate matrix/tensor equations to convert_matrix_block
+    if re.search(r"\\(?:mathbf|mathcal|begin\s*\{(?:Bmatrix|Vmatrix|array|bmatrix|matrix|pmatrix|smallmatrix|vmatrix)\})", block.body):
+        return None
+
     body_start = skip_ignorable(block.body, 0, len(block.body))
     prefix = read_operand(block.body, body_start)
     if prefix is None or not _is_derivative_prefix(prefix.text(block.body)):

color_math/converters/generic.py

@@ -15,6 +15,7 @@ from ..parsers.dimensionless import find_dimensionless_spans, collect_dimensionl
 from ..parsers.delimiters import collect_delimiter_spans
 from ..parsers.taxonomy import collect_taxonomy_spans
 from ..parsers.variable_hash import collect_variable_spans
+from ..parsers.physics import collect_quantum_operator_spans
 from ..utils.latex_helpers import contains_color_wrapper, normalize_latex_braces
 from ..utils.spans import ColorSpan, apply_color_spans
 from ..undo import uncolor_fragment
@@ -104,7 +105,14 @@ def color_latex_body(
         spans.extend(collect_single_constant_spans(normalized, pal))
 
     if opts.rainbow_delimiters:
-        spans.extend(collect_delimiter_spans(normalized))
+        spans.extend(
+            collect_delimiter_spans(
+                normalized,
+                for_latex_wrap=True,
+                include_bare_braces=opts.rainbow_bare_braces,
+                highlight_unmatched=opts.highlight_unmatched_braces,
+            )
+        )
 
     if opts.enable_taxonomy:
         spans.extend(collect_taxonomy_spans(normalized, pal, unit_spans, diff_spans, dim_spans))
@@ -112,6 +120,12 @@ def color_latex_body(
     if opts.variable_data_flow:
         spans.extend(collect_variable_spans(normalized, None, unit_spans, diff_spans, dim_spans, bare_functions))
 
+    if opts.color_quantum_operators or opts.field in ("quantum", "physics"):
+        quantum_spans = collect_quantum_operator_spans(normalized, pal, opts)
+        if quantum_spans:
+            spans = [s for s in spans if not any(q.start <= s.start and s.end <= q.end for q in quantum_spans)]
+            spans.extend(quantum_spans)
+
     return apply_color_spans(normalized, spans)
 
 

color_math/converters/matrix.py

@@ -15,7 +15,7 @@ from .semantic import first_equality, parse_math_block, relation_spans
 
 MATRIX_COMMAND_RE = re.compile(
     r"\\(?:mathbf|mathcal|nabla|det|tr|Tr|trace|Vert|lVert)"
-    r"(?![A-Za-z])|\\\|(?![A-Za-z])|"
+    r"(?![A-Za-z])|∇|\\\|(?![A-Za-z])|"
     r"\\operatorname\s*\{\s*tr\s*\}"
 )
 MATRIX_ENV_RE = re.compile(
@@ -126,13 +126,13 @@ def convert_matrix_block(source: str) -> str | None:
             if lhs_first.startswith((r"\det", r"\operatorname{tr}"))
             else ("main",)
         )
-    elif lhs_first.startswith((r"\frac{\partial}", r"\nabla")):
+    elif lhs_first.startswith((r"\frac{\partial}", r"\dfrac{\partial}", r"\tfrac{\partial}", r"\frac{∂}", r"\dfrac{∂}", r"\tfrac{∂}", r"\nabla", "∇")):
         lhs_colors = ("upper", "main")
     else:
         lhs_colors = ("upper", "chain", "orange")
 
     lhs_text = re.sub(r"\s+", "", block.body[:equality[0]])
-    if lhs_first.startswith(r"\frac{\partial}"):
+    if lhs_first.startswith((r"\frac{\partial}", r"\dfrac{\partial}", r"\tfrac{\partial}", r"\frac{∂}", r"\dfrac{∂}", r"\tfrac{∂}")):
         rhs_colors = ("chain", "main")
     elif len(lhs) > 1 and len(rhs) == 1:
         rhs_colors = ("main",)