chromamark 0.1.1__tar.gz

chromamark-0.1.1/LICENSE.md

@@ -0,0 +1,15 @@
+Copyright 2026 CJ Fravel
+
+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:
+
+1. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. **SaaS Provision**: If you use this software to provide a Software-as-a-Service (SaaS) offering, you must provide access to the source code of the modified version of the Software that you are using in your service, under the terms of this license. The access must be provided within a reasonable time, but no later than 30 days, and the access method should be publicly documented.
+
+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.
+
+---
+
+## Third-party components
+
+The published browser bundles in `packages/renderer/dist/` and the bundled VS Code extension embed [markdown-it](https://github.com/markdown-it/markdown-it), which is licensed under the [MIT License](https://github.com/markdown-it/markdown-it/blob/master/LICENSE).

chromamark-0.1.1/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: chromamark
+Version: 0.1.1
+Summary: ChromaMark for Python — render and build colored blocks, pills, collapsibles, fields, meters and inline diff on top of Markdown, with Jupyter display.
+Author: cjfravel-dev
+License: Copyright 2026 CJ Fravel
+        
+        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:
+        
+        1. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        2. **SaaS Provision**: If you use this software to provide a Software-as-a-Service (SaaS) offering, you must provide access to the source code of the modified version of the Software that you are using in your service, under the terms of this license. The access must be provided within a reasonable time, but no later than 30 days, and the access method should be publicly documented.
+        
+        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.
+        
+        ---
+        
+        ## Third-party components
+        
+        The published browser bundles in `packages/renderer/dist/` and the bundled VS Code extension embed [markdown-it](https://github.com/markdown-it/markdown-it), which is licensed under the [MIT License](https://github.com/markdown-it/markdown-it/blob/master/LICENSE).
+        
+Project-URL: Homepage, https://github.com/cjfravel-dev/ChromaMark
+Project-URL: Source, https://github.com/cjfravel-dev/ChromaMark
+Project-URL: Issues, https://github.com/cjfravel-dev/ChromaMark/issues
+Keywords: chromamark,markdown,markdown-it,jupyter,report,agent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Framework :: Jupyter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: markdown-it-py[linkify]>=3.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# chromamark (Python)
+
+Render and build [ChromaMark](https://github.com/cjfravel-dev/ChromaMark) from
+Python — colored blocks, pills, collapsible sections, fields, meters, and inline
+diff on top of Markdown (CommonMark + GFM). Produces the **same HTML** as the JS
+renderer, so the same theme applies, and it displays inline in Jupyter.
+
+Built on [markdown-it-py](https://github.com/executablebooks/markdown-it-py).
+
+## Install
+
+```bash
+pip install chromamark
+```
+
+## Render
+
+```python
+from chromamark import render, create_renderer
+
+html = render("::: success\nAll good [!ok pass]\n:::")
+
+# or as a markdown-it-py plugin:
+from markdown_it import MarkdownIt
+from chromamark import chromamark_plugin
+md = MarkdownIt("commonmark").use(chromamark_plugin)
+```
+
+## Build (fluent, for agent reports)
+
+```python
+from chromamark import ChromaDoc
+
+doc = ChromaDoc()
+doc.heading("Deploy report")
+doc.success("Deploy succeeded", "3/3 replicas healthy")
+doc.fields(Region="eastus", Status=doc.pill("ok", "healthy"))
+doc.table(["Stage", "Result"], [["unit", doc.pill("pass", "247")]])
+print(doc.to_cm())     # ChromaMark source
+print(doc.to_html())   # rendered HTML
+```
+
+## Jupyter
+
+```python
+from chromamark import display_chromamark
+display_chromamark("::: success\nRun complete [=success 100%]\n:::")
+```
+
+`ChromaDoc` also renders itself in notebooks via `_repr_html_`.
+
+## Parity with the JavaScript renderer
+
+`chromamark` produces byte-identical HTML to `@chromamark/renderer` for normal
+content — verified by a differential harness over ~140,000 inputs (every
+ChromaMark construct, GFM, linkify, and the full SPEC/demo documents all match
+exactly). Three **exotic** edge cases differ, all involving unusual whitespace or
+non-BMP characters; none affect typical agent-generated reports:
+
+- **Non-ASCII whitespace at a block edge** (e.g. a leading U+3000 ideographic
+  space): JS markdown-it preserves it (`asciiTrim`); markdown-it-py strips all
+  Unicode whitespace. Upstream base-engine difference.
+- **Six control/format code points inside ChromaMark constructs**
+  (U+001C–U+001F, U+0085 NEL, U+FEFF BOM): counted as whitespace by one engine's
+  regex/`strip` but not the other, which can flip pill/field parsing.
+- **Astral-plane (emoji) domain labels** in bare links (e.g. `🎉.com`): auto-linked
+  by JS linkify-it but not linkify-it-py. BMP and IDN letter hosts match.
+
+## Credits
+
+Inline change-tracking syntax is adopted from **[CriticMarkup](http://criticmarkup.com/)**
+(© 2013 Gabe Weatherhead & Erik Hess, Apache-2.0); ChromaMark's parser is an original,
+independent implementation. See the
+[main README](https://github.com/cjfravel-dev/ChromaMark#prior-art--credits) for full credits.
+
+## License
+
+Modified MIT License with a SaaS source-availability provision — see LICENSE.md.

chromamark-0.1.1/README.md

@@ -0,0 +1,78 @@
+# chromamark (Python)
+
+Render and build [ChromaMark](https://github.com/cjfravel-dev/ChromaMark) from
+Python — colored blocks, pills, collapsible sections, fields, meters, and inline
+diff on top of Markdown (CommonMark + GFM). Produces the **same HTML** as the JS
+renderer, so the same theme applies, and it displays inline in Jupyter.
+
+Built on [markdown-it-py](https://github.com/executablebooks/markdown-it-py).
+
+## Install
+
+```bash
+pip install chromamark
+```
+
+## Render
+
+```python
+from chromamark import render, create_renderer
+
+html = render("::: success\nAll good [!ok pass]\n:::")
+
+# or as a markdown-it-py plugin:
+from markdown_it import MarkdownIt
+from chromamark import chromamark_plugin
+md = MarkdownIt("commonmark").use(chromamark_plugin)
+```
+
+## Build (fluent, for agent reports)
+
+```python
+from chromamark import ChromaDoc
+
+doc = ChromaDoc()
+doc.heading("Deploy report")
+doc.success("Deploy succeeded", "3/3 replicas healthy")
+doc.fields(Region="eastus", Status=doc.pill("ok", "healthy"))
+doc.table(["Stage", "Result"], [["unit", doc.pill("pass", "247")]])
+print(doc.to_cm())     # ChromaMark source
+print(doc.to_html())   # rendered HTML
+```
+
+## Jupyter
+
+```python
+from chromamark import display_chromamark
+display_chromamark("::: success\nRun complete [=success 100%]\n:::")
+```
+
+`ChromaDoc` also renders itself in notebooks via `_repr_html_`.
+
+## Parity with the JavaScript renderer
+
+`chromamark` produces byte-identical HTML to `@chromamark/renderer` for normal
+content — verified by a differential harness over ~140,000 inputs (every
+ChromaMark construct, GFM, linkify, and the full SPEC/demo documents all match
+exactly). Three **exotic** edge cases differ, all involving unusual whitespace or
+non-BMP characters; none affect typical agent-generated reports:
+
+- **Non-ASCII whitespace at a block edge** (e.g. a leading U+3000 ideographic
+  space): JS markdown-it preserves it (`asciiTrim`); markdown-it-py strips all
+  Unicode whitespace. Upstream base-engine difference.
+- **Six control/format code points inside ChromaMark constructs**
+  (U+001C–U+001F, U+0085 NEL, U+FEFF BOM): counted as whitespace by one engine's
+  regex/`strip` but not the other, which can flip pill/field parsing.
+- **Astral-plane (emoji) domain labels** in bare links (e.g. `🎉.com`): auto-linked
+  by JS linkify-it but not linkify-it-py. BMP and IDN letter hosts match.
+
+## Credits
+
+Inline change-tracking syntax is adopted from **[CriticMarkup](http://criticmarkup.com/)**
+(© 2013 Gabe Weatherhead & Erik Hess, Apache-2.0); ChromaMark's parser is an original,
+independent implementation. See the
+[main README](https://github.com/cjfravel-dev/ChromaMark#prior-art--credits) for full credits.
+
+## License
+
+Modified MIT License with a SaaS source-availability provision — see LICENSE.md.

chromamark-0.1.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chromamark"
+version = "0.1.1"
+description = "ChromaMark for Python — render and build colored blocks, pills, collapsibles, fields, meters and inline diff on top of Markdown, with Jupyter display."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE.md" }
+authors = [{ name = "cjfravel-dev" }]
+keywords = ["chromamark", "markdown", "markdown-it", "jupyter", "report", "agent"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Text Processing :: Markup :: Markdown",
+  "Framework :: Jupyter",
+]
+dependencies = ["markdown-it-py[linkify]>=3.0"]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/cjfravel-dev/ChromaMark"
+Source = "https://github.com/cjfravel-dev/ChromaMark"
+Issues = "https://github.com/cjfravel-dev/ChromaMark/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+chromamark = ["theme.css"]

chromamark-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chromamark-0.1.1/src/chromamark/__init__.py

@@ -0,0 +1,49 @@
+"""ChromaMark for Python — renderer, builder, and Jupyter display.
+
+Produces the same HTML as the JavaScript ``@chromamark/renderer`` so the same
+theme applies. Built on markdown-it-py.
+"""
+
+import importlib.resources as _resources
+
+from markdown_it import MarkdownIt
+
+from .builder import ChromaDoc
+from .notebook import ChromaMarkHTML, display_chromamark
+from .plugin import chromamark_plugin
+from .tones import TONES, is_safe_color, parse_spec, resolve_tone
+
+__version__ = "0.1.1"
+
+
+def create_renderer(**options):
+    """Return a markdown-it-py instance configured for ChromaMark (CommonMark + GFM)."""
+    md = MarkdownIt("js-default", {"html": False, "linkify": True}).enable("linkify")
+    md.use(chromamark_plugin, **options)
+    return md
+
+
+def render(src, **options):
+    """Render a ChromaMark string to an HTML fragment."""
+    return create_renderer(**options).render("" if src is None else str(src))
+
+
+def get_theme():
+    """Return the ChromaMark theme stylesheet as a string."""
+    return (_resources.files("chromamark") / "theme.css").read_text(encoding="utf-8")
+
+
+__all__ = [
+    "render",
+    "create_renderer",
+    "chromamark_plugin",
+    "get_theme",
+    "ChromaDoc",
+    "display_chromamark",
+    "ChromaMarkHTML",
+    "resolve_tone",
+    "parse_spec",
+    "is_safe_color",
+    "TONES",
+    "__version__",
+]

chromamark-0.1.1/src/chromamark/builder.py

@@ -0,0 +1,120 @@
+"""ChromaDoc — a fluent builder that emits ChromaMark source (and renders it)."""
+
+import re
+
+_FENCE_RUN = re.compile(r"(?m)^\s*(:{3,})")
+
+
+class ChromaDoc:
+    """Assemble a ChromaMark document programmatically.
+
+    Every method returns ``self`` for chaining. Use :meth:`to_cm` for the
+    ChromaMark source, :meth:`to_html` to render, and it renders inline in
+    Jupyter via ``_repr_html_``.
+    """
+
+    def __init__(self):
+        self._blocks = []
+
+    # ---- inline helpers (return strings) ----
+    def pill(self, tone, label=None):
+        return f"[!{tone}]" if label is None else f"[!{tone} {label}]"
+
+    def tint(self, tone, label):
+        return f"[.{tone} {label}]"
+
+    def meter(self, tone, value):
+        return f"[={tone} {value}]"
+
+    # ---- block builders (append, return self) ----
+    def _add(self, chunk):
+        self._blocks.append(chunk)
+        return self
+
+    def raw(self, markdown_text):
+        return self._add(str(markdown_text))
+
+    def heading(self, text, level=2):
+        return self._add(f"{'#' * max(1, min(6, level))} {text}")
+
+    def paragraph(self, text):
+        return self._add(str(text))
+
+    def _body_to_cm(self, body):
+        if body is None:
+            return ""
+        if isinstance(body, ChromaDoc):
+            return body.to_cm().rstrip("\n")
+        return str(body)
+
+    def _fence_for(self, body_cm):
+        longest = 0
+        for match in _FENCE_RUN.finditer(body_cm or ""):
+            longest = max(longest, len(match.group(1)))
+        return ":" * max(3, longest + 1)
+
+    def _container(self, opener, body):
+        body_cm = self._body_to_cm(body)
+        fence = self._fence_for(body_cm) if body_cm else ":::"
+        head = f"{fence} {opener}"
+        if body_cm:
+            return f"{head}\n{body_cm}\n{fence}"
+        return f"{head}\n{fence}"
+
+    def block(self, tone, title=None, body=None):
+        opener = tone if not title else f"{tone} {title}"
+        return self._add(self._container(opener, body))
+
+    def success(self, title=None, body=None):
+        return self.block("success", title, body)
+
+    def info(self, title=None, body=None):
+        return self.block("info", title, body)
+
+    def tip(self, title=None, body=None):
+        return self.block("tip", title, body)
+
+    def warning(self, title=None, body=None):
+        return self.block("warning", title, body)
+
+    def danger(self, title=None, body=None):
+        return self.block("danger", title, body)
+
+    def muted(self, title=None, body=None):
+        return self.block("muted", title, body)
+
+    def details(self, summary, body=None, open=False, tone=None):
+        parts = ["details"]
+        if open:
+            parts.append("open")
+        if tone:
+            parts.append(tone)
+        parts.append(summary)
+        return self._add(self._container(" ".join(parts), body))
+
+    def fields(self, _map=None, **kwargs):
+        rows = {}
+        if _map:
+            rows.update(_map)
+        rows.update(kwargs)
+        lines = "\n".join(f"{k}: {v}" for k, v in rows.items())
+        fence = self._fence_for(lines)
+        return self._add(f"{fence} fields\n{lines}\n{fence}")
+
+    def table(self, headers, rows):
+        head = "| " + " | ".join(str(h) for h in headers) + " |"
+        sep = "| " + " | ".join("---" for _ in headers) + " |"
+        body = "\n".join("| " + " | ".join(str(c) for c in row) + " |" for row in rows)
+        return self._add("\n".join([head, sep, body]))
+
+    # ---- output ----
+    def to_cm(self):
+        return "\n\n".join(self._blocks) + "\n"
+
+    def to_html(self, **options):
+        from . import render
+        return render(self.to_cm(), **options)
+
+    def _repr_html_(self):
+        from . import get_theme
+        return f'<style>{get_theme()}</style>\n<div class="chromamark-output">{self.to_html()}</div>'

chromamark-0.1.1/src/chromamark/containers.py

@@ -0,0 +1,198 @@
+"""Block-level ChromaMark containers: ::: callout / details / fields."""
+
+from markdown_it.common.utils import escapeHtml
+
+from .tones import parse_spec, resolve_tone
+
+MIN_FENCE = 3
+
+
+def _cap(s):
+    return s[:1].upper() + s[1:]
+
+
+def _parse_opener(info):
+    if not info:
+        return None
+    tokens = info.split()
+    kind = tokens.pop(0).lower()
+
+    tone = None
+    color = None
+    is_open = False
+
+    if kind == "details":
+        structure = "details"
+    elif kind == "fields":
+        return {"structure": "fields"}
+    elif kind == "block":
+        structure = "callout"
+    else:
+        t = resolve_tone(kind)
+        if not t:
+            return None
+        structure = "callout"
+        tone = t
+
+    while tokens:
+        tk = tokens[0]
+        low = tk.lower()
+        if structure == "details" and low == "open":
+            is_open = True
+            tokens.pop(0)
+            continue
+        if low.startswith("color="):
+            spec = parse_spec(tk)
+            if spec and spec["color"]:
+                color = spec["color"]
+                tokens.pop(0)
+                continue
+            break
+        if structure == "details" and tone is None and resolve_tone(tk):
+            tone = resolve_tone(tk)
+            tokens.pop(0)
+            continue
+        break
+
+    rest = " ".join(tokens).strip()
+    if structure == "details":
+        return {"structure": "details", "tone": tone, "color": color,
+                "open": is_open, "summary": rest or "Details"}
+    return {"structure": structure, "tone": tone, "color": color,
+            "title": rest or (_cap(tone) if tone else "")}
+
+
+def _fence_len(src, pos, maximum):
+    count = 0
+    p = pos
+    while p < maximum and src[p] == ":":
+        count += 1
+        p += 1
+    return count
+
+
+def _make_rule(enabled):
+    def chroma_container(state, startLine, endLine, silent):
+        start = state.bMarks[startLine] + state.tShift[startLine]
+        maximum = state.eMarks[startLine]
+        if start >= len(state.src) or state.src[start] != ":":
+            return False
+
+        open_len = _fence_len(state.src, start, maximum)
+        if open_len < MIN_FENCE:
+            return False
+
+        parsed = _parse_opener(state.src[start + open_len:maximum].strip())
+        if not parsed or not enabled.get(parsed["structure"]):
+            return False
+        if silent:
+            return True
+
+        next_line = startLine
+        auto_closed = False
+        while True:
+            next_line += 1
+            if next_line >= endLine:
+                break
+            lstart = state.bMarks[next_line] + state.tShift[next_line]
+            lmax = state.eMarks[next_line]
+            if lstart >= len(state.src) or state.src[lstart] != ":":
+                continue
+            if state.sCount[next_line] - state.blkIndent >= 4:
+                continue
+            close_len = _fence_len(state.src, lstart, lmax)
+            if close_len < open_len:
+                continue
+            p = lstart + close_len
+            while p < lmax and state.src[p] in (" ", "\t"):
+                p += 1
+            if p < lmax:
+                continue
+            auto_closed = True
+            break
+
+        old_parent = state.parentType
+        old_line_max = state.lineMax
+        state.parentType = "chroma_container"
+        state.lineMax = next_line
+
+        if parsed["structure"] == "fields":
+            rows = []
+            ln = startLine + 1
+            while ln < next_line:
+                line = state.src[state.bMarks[ln] + state.tShift[ln]:state.eMarks[ln]]
+                if line.strip():
+                    ci = line.find(":")
+                    if ci == -1:
+                        rows.append((line.strip(), ""))
+                    else:
+                        rows.append((line[:ci].strip(), line[ci + 1:].strip()))
+                ln += 1
+            token = state.push("cm_fields", "", 0)
+            token.meta = {"rows": rows}
+            token.map = [startLine, next_line]
+        else:
+            open_token = state.push("cm_container_open", "div", 1)
+            open_token.meta = parsed
+            open_token.block = True
+            open_token.map = [startLine, next_line]
+
+            state.md.block.tokenize(state, startLine + 1, next_line)
+
+            close_token = state.push("cm_container_close", "div", -1)
+            close_token.meta = parsed
+            close_token.block = True
+
+        state.parentType = old_parent
+        state.lineMax = old_line_max
+        state.line = next_line + (1 if auto_closed else 0)
+        return True
+
+    return chroma_container
+
+
+def container_plugin(md, enabled):
+    md.block.ruler.before(
+        "fence", "cm_container", _make_rule(enabled),
+        {"alt": ["paragraph", "reference", "blockquote", "list"]},
+    )
+
+    def decorate(meta):
+        custom = " cm-custom" if meta.get("color") else ""
+        style = f' style="--fg:{escapeHtml(meta["color"])}"' if meta.get("color") else ""
+        tone = f' data-tone="{meta["tone"]}"' if (not meta.get("color") and meta.get("tone")) else ""
+        return custom, style, tone
+
+    def render_open(self, tokens, idx, options, env):
+        meta = tokens[idx].meta
+        custom, style, tone = decorate(meta)
+        if meta["structure"] == "details":
+            open_attr = " open" if meta.get("open") else ""
+            return (
+                f'<details class="cm-details{custom}"{tone}{style}{open_attr}>'
+                f'<summary>{escapeHtml(meta["summary"])}</summary><div class="cm-body">'
+            )
+        html = f'<div class="cm-block{custom}"{tone}{style}>'
+        if meta.get("title"):
+            html += f'<div class="cm-title">{escapeHtml(meta["title"])}</div>'
+        return html + '<div class="cm-body">'
+
+    def render_close(self, tokens, idx, options, env):
+        return "</div></details>" if tokens[idx].meta["structure"] == "details" else "</div></div>"
+
+    def render_fields(self, tokens, idx, options, env):
+        # Force html:false around renderInline so field values are escaped
+        # regardless of the host markdown-it configuration (defense in depth).
+        prev = md.options["html"]
+        md.options["html"] = False
+        try:
+            html = '<dl class="cm-fields">'
+            for key, value in tokens[idx].meta["rows"]:
+                html += f'<dt>{escapeHtml(key)}</dt><dd>{md.renderInline(value)}</dd>'
+            return html + "</dl>"
+        finally:
+            md.options["html"] = prev
+
+    md.add_render_rule("cm_container_open", render_open)
+    md.add_render_rule("cm_container_close", render_close)
+    md.add_render_rule("cm_fields", render_fields)

chromamark-0.1.1/src/chromamark/critic.py

@@ -0,0 +1,67 @@
+"""Inline diff via CriticMarkup: {++add++} {--del--} {~~old~>new~~} {==mark==} {>>comment<<}."""
+
+from markdown_it.common.utils import escapeHtml
+
+KINDS = {
+    "++": ("add", "++}"),
+    "--": ("del", "--}"),
+    "~~": ("sub", "~~}"),
+    "==": ("mark", "==}"),
+    ">>": ("comment", "<<}"),
+}
+
+
+def _rule(state, silent):
+    start = state.pos
+    src = state.src
+    if start >= state.posMax or src[start] != "{":
+        return False
+    spec = KINDS.get(src[start + 1:start + 3])
+    if not spec:
+        return False
+    kind, close = spec
+
+    content_start = start + 3
+    close_idx = src.find(close, content_start)
+    if close_idx == -1 or close_idx + len(close) > state.posMax:
+        return False
+
+    raw = src[content_start:close_idx]
+    if not silent:
+        tok = state.push("cm_critic", "", 0)
+        if kind == "sub":
+            cut = raw.find("~>")
+            tok.meta = {
+                "kind": "sub",
+                "old": raw if cut == -1 else raw[:cut],
+                "neu": "" if cut == -1 else raw[cut + 2:],
+            }
+        else:
+            tok.meta = {"kind": kind, "content": raw}
+
+    state.pos = close_idx + len(close)
+    return True
+
+
+def critic_plugin(md):
+    md.inline.ruler.before("emphasis", "cm_critic", _rule)
+
+    def render_critic(self, tokens, idx, options, env):
+        meta = tokens[idx].meta
+        kind = meta["kind"]
+        if kind == "add":
+            return f'<ins class="crit-add">{escapeHtml(meta["content"])}</ins>'
+        if kind == "del":
+            return f'<del class="crit-del">{escapeHtml(meta["content"])}</del>'
+        if kind == "sub":
+            return (
+                f'<del class="crit-del">{escapeHtml(meta["old"])}</del>'
+                f'<ins class="crit-add">{escapeHtml(meta["neu"])}</ins>'
+            )
+        if kind == "mark":
+            return f'<mark class="crit-mark">{escapeHtml(meta["content"])}</mark>'
+        if kind == "comment":
+            return f'<span class="crit-comment">{escapeHtml(meta["content"])}</span>'
+        return ""
+
+    md.add_render_rule("cm_critic", render_critic)