cmark-render 0.1.0__tar.gz

cmark_render-0.1.0/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2026, Zachary Juang
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

cmark_render-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+graft vendor
+graft tests
+include src/cmark_render/*.pyi src/cmark_render/py.typed
+global-exclude __pycache__ *.py[oc]

cmark_render-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: cmark-render
+Version: 0.1.0
+Summary: Fast, leak-free markdown to HTML with a vendored cmark-gfm (tables, ~~strikethrough~~, raw HTML).
+Author: Zachary Juang
+License-Expression: BSD-2-Clause
+Project-URL: Source, https://github.com/zachary822/cmark-render
+Keywords: markdown,commonmark,cmark,gfm
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: vendor/cmark-gfm/COPYING
+Dynamic: license-file
+
+# cmark-render
+
+Markdown to HTML in C, using a vendored, statically compiled
+[cmark-gfm](https://github.com/github/cmark-gfm).
+
+```python
+from cmark_render import render_html
+
+render_html("| a | b |\n|---|---|\n| ~~old~~ | **new** |")
+```
+
+`render_html` renders CommonMark plus:
+
+- GFM tables
+- strikethrough, on `~~double~~` tildes only (single `~` is left alone)
+- raw HTML passed through unchanged (`CMARK_OPT_UNSAFE`). **Sanitize the
+  output** if the input is untrusted.
+
+There are no options. The one function is all the package provides.
+
+## Why not cmarkgfm?
+
+`cmarkgfm` 2025.10.22 never frees the syntax tree or the rendered HTML, so
+each call leaks about 4x the size of its input. This binding frees every
+allocation that cmark hands back.
+
+It is also safe to use with threads and `fork()`. Renders run without the GIL
+but one at a time, because cmark-gfm keeps a global table of special
+characters that changes during each parse. A `pthread_atfork` handler stops a
+child process from inheriting a held lock.
+
+## Install
+
+```sh
+pip install cmark-render
+```
+
+Wheels are built for CPython 3.14 on macOS arm64 and manylinux x86_64 and
+aarch64. On other platforms, pip builds from the sdist, which needs a C
+compiler.
+
+## License
+
+BSD-2-Clause. The vendored cmark-gfm is under its own licenses, in
+`vendor/cmark-gfm/COPYING`. `vendor/cmark-gfm/UPSTREAM` records the upstream
+commit.

cmark_render-0.1.0/README.md

@@ -0,0 +1,46 @@
+# cmark-render
+
+Markdown to HTML in C, using a vendored, statically compiled
+[cmark-gfm](https://github.com/github/cmark-gfm).
+
+```python
+from cmark_render import render_html
+
+render_html("| a | b |\n|---|---|\n| ~~old~~ | **new** |")
+```
+
+`render_html` renders CommonMark plus:
+
+- GFM tables
+- strikethrough, on `~~double~~` tildes only (single `~` is left alone)
+- raw HTML passed through unchanged (`CMARK_OPT_UNSAFE`). **Sanitize the
+  output** if the input is untrusted.
+
+There are no options. The one function is all the package provides.
+
+## Why not cmarkgfm?
+
+`cmarkgfm` 2025.10.22 never frees the syntax tree or the rendered HTML, so
+each call leaks about 4x the size of its input. This binding frees every
+allocation that cmark hands back.
+
+It is also safe to use with threads and `fork()`. Renders run without the GIL
+but one at a time, because cmark-gfm keeps a global table of special
+characters that changes during each parse. A `pthread_atfork` handler stops a
+child process from inheriting a held lock.
+
+## Install
+
+```sh
+pip install cmark-render
+```
+
+Wheels are built for CPython 3.14 on macOS arm64 and manylinux x86_64 and
+aarch64. On other platforms, pip builds from the sdist, which needs a C
+compiler.
+
+## License
+
+BSD-2-Clause. The vendored cmark-gfm is under its own licenses, in
+`vendor/cmark-gfm/COPYING`. `vendor/cmark-gfm/UPSTREAM` records the upstream
+commit.

cmark_render-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=80"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cmark-render"
+version = "0.1.0"
+description = "Fast, leak-free markdown to HTML with a vendored cmark-gfm (tables, ~~strikethrough~~, raw HTML)."
+readme = "README.md"
+requires-python = ">=3.14"
+license = "BSD-2-Clause"
+license-files = ["LICENSE", "vendor/cmark-gfm/COPYING"]
+authors = [{ name = "Zachary Juang" }]
+keywords = ["markdown", "commonmark", "cmark", "gfm"]
+classifiers = [
+    "Programming Language :: C",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: Text Processing :: Markup :: Markdown",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Source = "https://github.com/zachary822/cmark-render"
+
+[tool.setuptools.package-data]
+cmark_render = ["py.typed", "*.pyi"]
+
+[tool.setuptools.exclude-package-data]
+cmark_render = ["*.c"]
+
+[tool.cibuildwheel]
+build = "cp314-*"
+# GIL builds on glibc only.
+skip = "cp314t-* *-musllinux_*"
+test-command = "python -m unittest discover -s {project}/tests -v"
+
+[tool.uv]
+# uv only rebuilds the project when a cache key changes; include the C.
+cache-keys = [
+    { file = "pyproject.toml" },
+    { file = "setup.py" },
+    { file = "src/**/*.c" },
+    { file = "vendor/**/*" },
+]

cmark_render-0.1.0/setup.cfg

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

cmark_render-0.1.0/setup.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from setuptools import Extension, setup
+
+CMARK = Path("vendor/cmark-gfm")
+sources = [
+    "src/cmark_render/_cmark.c",
+    *sorted(str(path) for path in (CMARK / "src").glob("*.c")),
+    *sorted(str(path) for path in (CMARK / "extensions").glob("*.c")),
+]
+
+setup(
+    ext_modules=[
+        Extension(
+            "cmark_render._cmark",
+            sources=sources,
+            include_dirs=[str(CMARK / d) for d in ("src", "extensions", "generated")],
+            # Compiled in, not linked against a shared libcmark-gfm.
+            define_macros=[("CMARK_GFM_STATIC_DEFINE", None)],
+        )
+    ],
+)

cmark_render-0.1.0/src/cmark_render/__init__.py

@@ -0,0 +1,5 @@
+"""Fast, leak-free markdown to HTML with a vendored cmark-gfm."""
+
+from cmark_render._cmark import render_html
+
+__all__ = ["render_html"]

cmark_render-0.1.0/src/cmark_render/_cmark.c

@@ -0,0 +1,122 @@
+/* Renders markdown with cmark-gfm: CommonMark plus the
+ * strikethrough and table extensions, raw HTML passed through
+ * (CMARK_OPT_UNSAFE), and strikethrough only on "~~".
+ *
+ * Every allocation cmark hands back is freed here. The cmarkgfm package
+ * leaked the syntax tree and the rendered HTML on each call.
+ */
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include <pthread.h>
+#include <string.h>
+
+#include "cmark-gfm.h"
+#include "cmark-gfm-core-extensions.h"
+
+#define RENDER_OPTIONS (CMARK_OPT_UNSAFE | CMARK_OPT_STRIKETHROUGH_DOUBLE_TILDE)
+
+static cmark_syntax_extension *strikethrough;
+static cmark_syntax_extension *table;
+
+/* While parsing inlines, cmark adds each extension's characters ("~" for
+ * strikethrough) to a global table and clears them after
+ * (cmark_manage_extensions_special_characters), so a concurrent parse could
+ * lose its strikethrough. Renders run without the GIL, one at a time. */
+static pthread_mutex_t render_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/* A fork while another thread holds render_lock would leave the child with a
+ * lock nothing releases. Forking waits for the render and unlocks in both. */
+static void lock_render(void) { pthread_mutex_lock(&render_lock); }
+static void unlock_render(void) { pthread_mutex_unlock(&render_lock); }
+
+static PyObject *render_html(PyObject *module, PyObject *arg) {
+  if (!PyUnicode_Check(arg)) {
+    PyErr_Format(PyExc_TypeError,
+                 "render_html() argument must be str, not %.200s",
+                 Py_TYPE(arg)->tp_name);
+    return NULL;
+  }
+  Py_ssize_t length;
+  const char *text = PyUnicode_AsUTF8AndSize(arg, &length);
+  if (text == NULL) {
+    return NULL;
+  }
+
+  /* text points into arg, which the caller keeps alive for the call. */
+  char *html = NULL;
+  Py_BEGIN_ALLOW_THREADS
+  /* Taken without the GIL, so a thread waiting here can't block one that
+   * holds the lock and needs the GIL back. */
+  pthread_mutex_lock(&render_lock);
+  cmark_parser *parser = cmark_parser_new(RENDER_OPTIONS);
+  cmark_parser_attach_syntax_extension(parser, strikethrough);
+  cmark_parser_attach_syntax_extension(parser, table);
+  cmark_parser_feed(parser, text, (size_t)length);
+  /* The parser hands the tree to the caller; cmark_parser_free leaves it. */
+  cmark_node *document = cmark_parser_finish(parser);
+  if (document != NULL) {
+    html = cmark_render_html(document, RENDER_OPTIONS,
+                             cmark_parser_get_syntax_extensions(parser));
+    cmark_node_free(document);
+  }
+  cmark_parser_free(parser);
+  pthread_mutex_unlock(&render_lock);
+  Py_END_ALLOW_THREADS
+
+  if (html == NULL) {
+    PyErr_SetString(PyExc_RuntimeError, "cmark returned no document");
+    return NULL;
+  }
+  PyObject *result = PyUnicode_DecodeUTF8(html, (Py_ssize_t)strlen(html), NULL);
+  /* cmark_render_html allocates with the tree's allocator, which is the
+   * default one for a parser from cmark_parser_new. */
+  cmark_get_default_mem_allocator()->free(html);
+  return result;
+}
+
+static int exec_module(PyObject *module) {
+  static int fork_handlers_registered = 0;
+  if (!fork_handlers_registered) {
+    if (pthread_atfork(lock_render, unlock_render, unlock_render) != 0) {
+      PyErr_SetString(PyExc_ImportError, "pthread_atfork failed");
+      return -1;
+    }
+    fork_handlers_registered = 1;
+  }
+  cmark_gfm_core_extensions_ensure_registered();
+  strikethrough = cmark_find_syntax_extension("strikethrough");
+  table = cmark_find_syntax_extension("table");
+  if (strikethrough == NULL || table == NULL) {
+    PyErr_SetString(PyExc_ImportError,
+                    "cmark-gfm is missing the strikethrough or table extension");
+    return -1;
+  }
+  return 0;
+}
+
+PyDoc_STRVAR(render_html_doc,
+             "render_html($module, text, /)\n--\n\n"
+             "Render markdown to HTML with the strikethrough and table "
+             "extensions, passing raw HTML through.");
+
+static PyMethodDef methods[] = {
+    {"render_html", render_html, METH_O, render_html_doc},
+    {NULL, NULL, 0, NULL},
+};
+
+static PyModuleDef_Slot slots[] = {
+    {Py_mod_exec, exec_module},
+    {0, NULL},
+};
+
+static struct PyModuleDef module_def = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "cmark_render._cmark",
+    .m_doc = "Markdown rendering with cmark-gfm.",
+    .m_size = 0,
+    .m_methods = methods,
+    .m_slots = slots,
+};
+
+PyMODINIT_FUNC PyInit__cmark(void) { return PyModuleDef_Init(&module_def); }

cmark_render-0.1.0/src/cmark_render/_cmark.pyi

@@ -0,0 +1 @@
+def render_html(text: str, /) -> str: ...

cmark_render-0.1.0/src/cmark_render.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: cmark-render
+Version: 0.1.0
+Summary: Fast, leak-free markdown to HTML with a vendored cmark-gfm (tables, ~~strikethrough~~, raw HTML).
+Author: Zachary Juang
+License-Expression: BSD-2-Clause
+Project-URL: Source, https://github.com/zachary822/cmark-render
+Keywords: markdown,commonmark,cmark,gfm
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: vendor/cmark-gfm/COPYING
+Dynamic: license-file
+
+# cmark-render
+
+Markdown to HTML in C, using a vendored, statically compiled
+[cmark-gfm](https://github.com/github/cmark-gfm).
+
+```python
+from cmark_render import render_html
+
+render_html("| a | b |\n|---|---|\n| ~~old~~ | **new** |")
+```
+
+`render_html` renders CommonMark plus:
+
+- GFM tables
+- strikethrough, on `~~double~~` tildes only (single `~` is left alone)
+- raw HTML passed through unchanged (`CMARK_OPT_UNSAFE`). **Sanitize the
+  output** if the input is untrusted.
+
+There are no options. The one function is all the package provides.
+
+## Why not cmarkgfm?
+
+`cmarkgfm` 2025.10.22 never frees the syntax tree or the rendered HTML, so
+each call leaks about 4x the size of its input. This binding frees every
+allocation that cmark hands back.
+
+It is also safe to use with threads and `fork()`. Renders run without the GIL
+but one at a time, because cmark-gfm keeps a global table of special
+characters that changes during each parse. A `pthread_atfork` handler stops a
+child process from inheriting a held lock.
+
+## Install
+
+```sh
+pip install cmark-render
+```
+
+Wheels are built for CPython 3.14 on macOS arm64 and manylinux x86_64 and
+aarch64. On other platforms, pip builds from the sdist, which needs a C
+compiler.
+
+## License
+
+BSD-2-Clause. The vendored cmark-gfm is under its own licenses, in
+`vendor/cmark-gfm/COPYING`. `vendor/cmark-gfm/UPSTREAM` records the upstream
+commit.

cmark_render-0.1.0/src/cmark_render.egg-info/SOURCES.txt

@@ -0,0 +1,82 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+src/cmark_render/__init__.py
+src/cmark_render/_cmark.c
+src/cmark_render/_cmark.pyi
+src/cmark_render/py.typed
+src/cmark_render.egg-info/PKG-INFO
+src/cmark_render.egg-info/SOURCES.txt
+src/cmark_render.egg-info/dependency_links.txt
+src/cmark_render.egg-info/top_level.txt
+tests/test_render.py
+vendor/cmark-gfm/COPYING
+vendor/cmark-gfm/UPSTREAM
+vendor/cmark-gfm/extensions/autolink.c
+vendor/cmark-gfm/extensions/autolink.h
+vendor/cmark-gfm/extensions/cmark-gfm-core-extensions.h
+vendor/cmark-gfm/extensions/core-extensions.c
+vendor/cmark-gfm/extensions/ext_scanners.c
+vendor/cmark-gfm/extensions/ext_scanners.h
+vendor/cmark-gfm/extensions/strikethrough.c
+vendor/cmark-gfm/extensions/strikethrough.h
+vendor/cmark-gfm/extensions/table.c
+vendor/cmark-gfm/extensions/table.h
+vendor/cmark-gfm/extensions/tagfilter.c
+vendor/cmark-gfm/extensions/tagfilter.h
+vendor/cmark-gfm/extensions/tasklist.c
+vendor/cmark-gfm/extensions/tasklist.h
+vendor/cmark-gfm/generated/cmark-gfm_export.h
+vendor/cmark-gfm/generated/cmark-gfm_version.h
+vendor/cmark-gfm/generated/config.h
+vendor/cmark-gfm/src/arena.c
+vendor/cmark-gfm/src/blocks.c
+vendor/cmark-gfm/src/buffer.c
+vendor/cmark-gfm/src/buffer.h
+vendor/cmark-gfm/src/case_fold_switch.inc
+vendor/cmark-gfm/src/chunk.h
+vendor/cmark-gfm/src/cmark-gfm-extension_api.h
+vendor/cmark-gfm/src/cmark-gfm.h
+vendor/cmark-gfm/src/cmark.c
+vendor/cmark-gfm/src/cmark_ctype.c
+vendor/cmark-gfm/src/cmark_ctype.h
+vendor/cmark-gfm/src/commonmark.c
+vendor/cmark-gfm/src/entities.inc
+vendor/cmark-gfm/src/footnotes.c
+vendor/cmark-gfm/src/footnotes.h
+vendor/cmark-gfm/src/houdini.h
+vendor/cmark-gfm/src/houdini_href_e.c
+vendor/cmark-gfm/src/houdini_html_e.c
+vendor/cmark-gfm/src/houdini_html_u.c
+vendor/cmark-gfm/src/html.c
+vendor/cmark-gfm/src/html.h
+vendor/cmark-gfm/src/inlines.c
+vendor/cmark-gfm/src/inlines.h
+vendor/cmark-gfm/src/iterator.c
+vendor/cmark-gfm/src/iterator.h
+vendor/cmark-gfm/src/latex.c
+vendor/cmark-gfm/src/linked_list.c
+vendor/cmark-gfm/src/man.c
+vendor/cmark-gfm/src/map.c
+vendor/cmark-gfm/src/map.h
+vendor/cmark-gfm/src/node.c
+vendor/cmark-gfm/src/node.h
+vendor/cmark-gfm/src/parser.h
+vendor/cmark-gfm/src/plaintext.c
+vendor/cmark-gfm/src/plugin.c
+vendor/cmark-gfm/src/plugin.h
+vendor/cmark-gfm/src/references.c
+vendor/cmark-gfm/src/references.h
+vendor/cmark-gfm/src/registry.c
+vendor/cmark-gfm/src/registry.h
+vendor/cmark-gfm/src/render.c
+vendor/cmark-gfm/src/render.h
+vendor/cmark-gfm/src/scanners.c
+vendor/cmark-gfm/src/scanners.h
+vendor/cmark-gfm/src/syntax_extension.c
+vendor/cmark-gfm/src/syntax_extension.h
+vendor/cmark-gfm/src/utf8.c
+vendor/cmark-gfm/src/utf8.h
+vendor/cmark-gfm/src/xml.c

cmark_render-0.1.0/src/cmark_render.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cmark_render-0.1.0/src/cmark_render.egg-info/top_level.txt

@@ -0,0 +1 @@
+cmark_render

cmark_render-0.1.0/tests/test_render.py

@@ -0,0 +1,108 @@
+import os
+import resource
+import signal
+import sys
+import threading
+import time
+import unittest
+from concurrent.futures import ThreadPoolExecutor
+
+from cmark_render import render_html
+
+
+class RenderHtmlTests(unittest.TestCase):
+    def test_strikethrough(self) -> None:
+        self.assertIn("<del>old</del>", render_html("The ~~old~~ road"))
+
+    def test_single_tildes_stay_literal(self) -> None:
+        rendered = render_html('"Got~cha~♪"')
+
+        self.assertNotIn("<del>", rendered)
+        self.assertIn("Got~cha~♪", rendered)
+
+    def test_passes_raw_html_through(self) -> None:
+        self.assertEqual(
+            render_html("<em>Roar</em> of the <Dragon King>"),
+            "<p><em>Roar</em> of the <Dragon King></p>\n",
+        )
+
+    def test_tables(self) -> None:
+        rendered = render_html("| Name | Rank |\n|---|:-:|\n| Kaito | S |")
+
+        self.assertIn("<table>", rendered)
+        self.assertIn("<th>Name</th>", rendered)
+        self.assertIn('<td align="center">S</td>', rendered)
+
+    def test_unicode(self) -> None:
+        self.assertEqual(
+            render_html("「会話」と**強調** 🐉"),
+            "<p>「会話」と<strong>強調</strong> 🐉</p>\n",
+        )
+
+    def test_rejects_non_str(self) -> None:
+        with self.assertRaises(TypeError):
+            render_html(b"bytes")  # type: ignore[arg-type]
+
+    def test_releases_memory(self) -> None:
+        # cmarkgfm leaked each render's syntax tree and HTML, ~4x the input.
+        text = "\n\n".join(["Some *markdown*, ~~struck~~, | a | table |."] * 1800)
+        for _ in range(50):
+            render_html(text)
+        before = _peak_rss_mb()
+        for _ in range(2000):
+            render_html(text)
+
+        self.assertLess(_peak_rss_mb() - before, 20)
+
+    def test_renders_correctly_from_many_threads(self) -> None:
+        # Each parse sets and clears cmark's global "~" entry; overlapping
+        # parses would drop strikethrough.
+        text = "\n\n".join(
+            f"Line {n}: the ~~old~~ road and ~~new~~ path" for n in range(40)
+        )
+        expected = render_html(text)
+
+        with ThreadPoolExecutor(max_workers=8) as pool:
+            results = list(pool.map(lambda _: render_html(text), range(800)))
+
+        self.assertTrue(all(result == expected for result in results))
+
+    def test_renders_in_a_child_forked_mid_render(self) -> None:
+        text = "\n\n".join(["Some ~~struck~~ text."] * 2000)
+        stop = threading.Event()
+
+        def keep_rendering() -> None:
+            while not stop.is_set():
+                render_html(text)
+
+        renderer = threading.Thread(target=keep_rendering)
+        renderer.start()
+        try:
+            time.sleep(0.05)
+            pid = os.fork()
+            if pid == 0:
+                # A render lock inherited in the locked state would hang here.
+                ok = "<del>struck</del>" in render_html("Some ~~struck~~ text.")
+                os._exit(0 if ok else 1)
+        finally:
+            stop.set()
+            renderer.join()
+
+        deadline = time.monotonic() + 10
+        while (status := os.waitpid(pid, os.WNOHANG))[0] == 0:
+            if time.monotonic() > deadline:
+                os.kill(pid, signal.SIGKILL)
+                os.waitpid(pid, 0)
+                self.fail("child process deadlocked rendering markdown")
+            time.sleep(0.01)
+        self.assertEqual(os.waitstatus_to_exitcode(status[1]), 0)
+
+
+def _peak_rss_mb() -> float:
+    peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+    # ru_maxrss is bytes on macOS and kilobytes on Linux.
+    return peak / (1024 * 1024 if sys.platform == "darwin" else 1024)
+
+
+if __name__ == "__main__":
+    unittest.main()