justhtml 3.4.0__tar.gz → 3.6.0__tar.gz

{justhtml-3.4.0 → justhtml-3.6.0}/.github/workflows/ci.yml

@@ -20,10 +20,10 @@ jobs:
       PYTHONHASHSEED: "0"
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           cache: "pip"
@@ -45,8 +45,6 @@ jobs:
         run: |
           cd ..
           git clone --filter=blob:none --sparse https://github.com/web-platform-tests/wpt.git
-          git -C wpt fetch origin 75b089d70448e1da425ab8cf38971b6af41f3cea
-          git -C wpt checkout 75b089d70448e1da425ab8cf38971b6af41f3cea
           git -C wpt sparse-checkout set html/syntax/parsing/resources
           git -C wpt rev-parse HEAD
 
@@ -84,15 +82,15 @@ jobs:
   test-pyodide:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           node-version: "20"
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.12"
 

{justhtml-3.4.0 → justhtml-3.6.0}/.github/workflows/publish.yml

@@ -17,10 +17,10 @@ jobs:
       contents: read
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.x"
 

{justhtml-3.4.0 → justhtml-3.6.0}/.pre-commit-config.yaml

@@ -33,7 +33,7 @@ repos:
     hooks:
       - id: tests-coverage
         name: Tests & Coverage
-        entry: bash -c 'coverage run run_tests.py && coverage report'
+        entry: bash -c 'coverage run run_tests.py --no-write-summary && coverage report'
         language: system
         pass_filenames: false
         always_run: true

justhtml-3.6.0/AGENTS.md

@@ -0,0 +1,10 @@
+# Agent Contribution Guide
+
+Read these files before making changes:
+
+- [CONTRIBUTING.md](CONTRIBUTING.md) for development, tests, documentation
+  examples, changelog, and release expectations.
+- [SECURITY.md](SECURITY.md) for the untrusted-HTML threat model and security
+  boundaries.
+- [PERFORMANCE.md](PERFORMANCE.md) for parser-speed benchmarking and
+  optimization work.

{justhtml-3.4.0 → justhtml-3.6.0}/CHANGELOG.md

@@ -7,6 +7,68 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.0] - 2026-07-13
+
+### Fixed
+Note: The below are all minor parsing differences found when diffing against Chromium output, that is not covered in WPT's html5 parsing tests.
+
+- Add a formatting element that breaks out of foreign content (such as `<i>` inside `<svg>`) to the active formatting list, so it is reconstructed later. Previously, the breakout element was inserted but not tracked, so `<b><svg><i></b>z` dropped the reconstructed `<i>` around the trailing text and `<svg><code><h2></code>` lost the reconstructed `<code>`.
+- Start the body for a `<noscript>` start tag in the "after head" insertion mode instead of re-entering the head. The after-head metadata list does not include noscript, so markup such as `</head><noscript>` now places the element in the body.
+- Hand an end tag to the HTML rules when the foreign-content end-tag walk reaches a matching HTML element, rather than popping the foreign elements above it. Previously, `<form><math></form>` popped the `<math>` along with the form instead of splicing only the form out of the stack.
+- Clear back to the template contents before opening table structure in a template with no table element, so an open caption is closed. Previously, `<template><caption><tr>` nested the row inside the caption instead of making it a sibling.
+- Switch the "in template" mode into the body for a non-head raw-text or RCDATA start tag (`iframe`, `noembed`, `xmp`, `textarea`), which are dispatched before the template-mode handler. Previously, a following table-structure tag such as the `<td>` in `<template><xmp></xmp><td>` created a spurious cell instead of being dropped.
+- Ignore a `</td>` or `</th>` end tag in a template cell when the matching cell type is not in table scope. Previously, `<template><td></th>x` closed the `<td>` on the mismatched `</th>`, so the following text became a sibling instead of staying in the cell.
+- Insert a non-breakout HTML-named start tag inside foreign content as a foreign element without running HTML in-body recovery. Foreign elements sharing a name with an HTML scope boundary or table foster target (an SVG or MathML `td`, `tr`, `caption`, ...) no longer stop scope walks or foster their children out. Previously, markup such as `<p><svg><article>`, `<p><math><td><listing>`, and `<table><math><tr><d>` broke out of or escaped the foreign subtree.
+- Ignore `</body>` and `</html>` whenever a select is open, not only when the select holds just options. Previously, an element retained inside the select (as in `<select><o></body><!--x-->`) let the end tag switch to the after-body mode, moving following content out of the select.
+- Close a raw-text or RCDATA element when its end tag name is terminated by `/` or a space even without a closing `>`. Previously, `<style></style/x` kept the unterminated end tag as text and left the element open.
+- Do not reconstruct the active formatting elements for `rb`, `rp`, `rt`, or `rtc` start tags. Previously, `<div><tt></div><rt>` wrapped the `<rt>` in a stale `<tt>` instead of inserting it directly.
+- Ignore `</form>` when the form element is not in scope, such as behind an open `<table>`. Previously, `<form><table></form><table>` removed the form from the stack, so the following table became a sibling of the form instead of nesting inside it.
+- Respect special-element blocking for generic end tags inside a template. Previously, `<template><dialog><object></dialog>e` closed the dialog through the open `<object>` instead of ignoring the end tag, so following text escaped the object.
+- Place a comment after an explicit `</head>` between the head and body even when the head contains a template. Previously, `<head><template></template></head><!--c-->` kept the comment inside the head.
+- Process in-body `base`, `link`, and `meta` start tags with the in-head rules without reconstructing the active formatting elements. Previously, markup such as `<p><u><section><meta>` could wrongly wrap the metadata element in a stale formatting element instead of inserting it directly.
+- Check the script-data-double-escape-start terminator against the real following character. Previously, a `<script` immediately followed by `</script>` inside a script (for example `<script><!--<script</script>`) entered the double-escaped state and swallowed the closing tag, leaving the script element unclosed.
+- Pop foreign-content ancestors before applying the heading start-tag rule so a heading that breaks out of MathML or SVG closes an open heading. Previously, markup such as `<h1><math><h3>` nested the second heading inside the first instead of making it a sibling.
+- Ignore `</html>` and `</body>` end tags in the "in select" insertion mode instead of switching to the after-body/after-html modes. Previously, markup such as `<select></html><!--c-->` moved trailing comments out of the still-open select to the document level.
+- Restrict character foster parenting to HTML table elements. Previously, a foreign SVG or MathML element that merely shared a name with a table foster target (such as an SVG `<tr>`) had following text foster-parented out of the foreign subtree instead of kept as its child, as in `<table><svg><tr>n`.
+- Force quirks mode when a doctype has trailing junk after its name without a PUBLIC or SYSTEM keyword. Previously, `<!DOCTYPE html foo>` was treated as no-quirks, so a following `<table>` incorrectly closed an open `<p>`.
+- Ignore end tags other than `</template>` in the "in template" insertion mode. Previously, the `</br>` special case still ran, so `<template></br>` created a stray `<br>` inside the template contents.
+- Let table-scoped end tags follow the foreign-content end-tag algorithm when the current node is a MathML or SVG element. Previously, an end tag such as `</th>` inside foreign content was routed to HTML table recovery, so `<svg><th><o></th>0` left the foreign cell open and misplaced the following text.
+- Ignore `</body>` and `</html>` when no body element is in scope. Previously, an open scope marker such as `<marquee>`, `<object>`, or `<applet>` did not prevent the switch to the after-body mode, so following content such as a comment in `<marquee></body><!--x-->` was placed outside the still-open element.
+- Close an escaped script comment on `<!-->`, whose `<!--` dashes already count toward the `-->`. Previously, `<script><!--><script></script>` treated the following `<script>` as a double-escape start and swallowed the closing tag, leaving the script element unclosed.
+- Push active-formatting markers only for HTML scope-marker elements. A foreign element sharing a name such as an SVG or MathML `<td>` no longer pushes a marker that would linger after the element is popped and block later formatting reconstruction, as in `<p><a><math><td></td><listing>U`.
+
+## [3.5.0] - 2026-07-13
+
+### Changed
+- Add contributor guidance for documentation examples, security and availability reviews, releases, and a new `PERFORMANCE.md` workflow for measuring and testing performance improvements.
+- Add TurboHTML to the correctness benchmarks, and refresh the comparison guide with current Python-parser and browser-engine scores. Many dropped because of the new tests around processing instructions.
+- Run CI against the latest WPT tree-construction fixtures rather than a pinned revision.
+
+### Fixed
+Note: The below are all minor parsing differences found when diffing against Chromium output, that is not covered in WPT's html5 parsing tests.
+
+- Ignore null-plus-whitespace character runs in the post-doctype document shell before creating the body. Previously, removing the null after classification could leave a spurious newline in `<body>`.
+- Ignore late `<head>` start tags after body text even when the fast text path has not marked body mode explicitly. Previously, following metadata could be moved from the body back into the head.
+- Limit doctype tokenization whitespace to the HTML ASCII whitespace set. Previously, non-ASCII spaces such as NBSP could be discarded instead of becoming part of the doctype name.
+- Preserve the `frameset-ok` state across empty active-formatting elements. Previously, markup such as `<i><frameset>` could retain an empty body instead of replacing it with the frameset.
+- Keep comments following implied head metadata in the head. Previously, `<meta><!--...-->` could place the comment before the document element.
+- Exit column-group mode before reprocessing malformed end tags. Previously, `<table><colgroup></p>` could leave a paragraph inside the colgroup instead of foster-parenting it before the table.
+- Keep foreign elements named `colgroup` out of HTML table recovery. Previously, text following SVG or MathML `<colgroup>` could become a sibling instead of its child.
+- Keep form controls in template contents when a template appears inside `<select>`. Previously, an `<input>` could prematurely close the outer select.
+- Keep initial-template recovery in the head insertion mode after `</template>`. Previously, following head whitespace could be discarded.
+- Match the latest WPT processing-instruction tree expectations, including empty data fields and the `<?#` bogus-comment case.
+- Close an open template `<colgroup>` before processing following script and style tags. Previously, those tags could be incorrectly inserted inside the column group.
+- Recover table-body start tags correctly inside templates. Previously, a following `<colgroup>` could be discarded instead of closing the current table body.
+- Close template table bodies before handling `</table>`. Previously, following content could remain incorrectly nested inside `<tbody>`.
+- Close template rows before handling `</table>`. Previously, following nested templates could remain incorrectly nested inside `<tr>`.
+- Ignore nested table starts in template table modes that have no open table. Previously, malformed input could create a spurious empty `<table>`.
+- Resume template body recovery after `<title>`. Previously, invalid table-structure tags following a template title could create incorrect table nodes.
+- Resume template body recovery after base and noframes head-content tags. Previously, invalid following table-structure tags could create incorrect table nodes.
+- Apply phantom paragraph recovery inside templates. Previously, an unmatched `</p>` could be incorrectly ignored.
+- Keep unmatched `</p>` ignored in the template initial insertion mode.
+- Keep template table-body recovery scoped to an open table. Previously, a nested table token could close and duplicate synthetic table bodies.
+- Preserve open template tables when closing a select. Previously, following option content could be placed outside the select.
+
 ## [3.4.0] - 2026-07-11
 
 ### Security

{justhtml-3.4.0 → justhtml-3.6.0}/CONTRIBUTING.md

@@ -49,6 +49,28 @@ python -c 'from justhtml import JustHTML, to_test_format; print(to_test_format(J
 
 **Coverage is required to be 100%.** All new code must be fully tested.
 
+### Documentation examples
+
+Runnable documentation examples use an explicit output marker. Place it between
+a self-contained Python fence and the expected-output fence:
+
+````text
+```python
+from justhtml import JustHTML
+print(JustHTML("<p>x</p>", fragment=True).to_html())
+```
+
+<!-- justhtml: output -->
+
+```html
+<p>x</p>
+```
+````
+
+The docs test executes each marked Python block independently and compares its
+stdout with the following fence. Keep ordinary HTML fences unmarked so they
+remain explanatory examples rather than tests.
+
 ## Pre-commit Hooks
 
 Pre-commit runs automatically on every commit and checks:
@@ -85,12 +107,25 @@ After making changes, verify performance impact:
 
 ```bash
 # Quick benchmark
-python benchmarks/performance.py --iterations 1 --parser justhtml --no-mem
+python benchmarks/performance.py --parsers justhtml --iterations 1
 
 # Profile hotspots
 python benchmarks/profile.py
 ```
 
+For a parser-speed improvement, measure the relevant pipeline on the web100k
+corpus before and after the change; see [PERFORMANCE.md](PERFORMANCE.md). For
+an availability fix, add a regression that exercises the affected hostile-input
+shape and verify that growth is linear or otherwise bounded.
+
+## Releases
+
+Use `python scripts/release.py --version X.Y.Z --yes` for releases. The script
+runs release checks, bumps `pyproject.toml`, commits, tags, pushes, and creates
+the GitHub release. Before invoking it, ensure the worktree is clean and move
+the relevant Unreleased changelog entries into a dated `## [X.Y.Z]` section;
+the helper requires that section to exist.
+
 ## Architecture Notes
 
 - **Parser engine** (`src/justhtml/parser/engine.py`): Plan-driven tokenization, tree construction, and sanitizer projection
@@ -109,8 +144,9 @@ Golden rules:
 
 1. Fork the repository
 2. Create a feature branch
-3. Make your changes with tests
-4. Ensure pre-commit passes
-5. Submit a pull request
+3. Add an entry under the relevant section of `CHANGELOG.md`
+4. Make your changes with tests
+5. Ensure pre-commit passes
+6. Submit a pull request
 
 Questions? Open an issue on GitHub. For security vulnerabilities, please see our [Security Policy](SECURITY.md).

justhtml-3.6.0/PERFORMANCE.md

@@ -0,0 +1,84 @@
+# Performance Guide
+
+This guide is for improving JustHTML's parsing speed on real-world HTML while
+preserving its HTML5 recovery and sanitization behavior.
+
+## Benchmark data and setup
+
+The main benchmark uses the [web100k](https://github.com/EmilStenstrom/web100k)
+corpus. By default it expects the dataset beside this repository:
+
+```text
+../web100k/
+├── html.dict
+└── batches/
+    └── web100k-batch-001.tar.zst
+```
+
+Set `WEB100K_DIR` to use another location, or pass `--batches-dir` and
+`--dict` explicitly. Install the benchmark dependencies first:
+
+```bash
+pip install -e ".[benchmark]"
+```
+
+## Measure the right pipeline
+
+The benchmark has separate modes for parsing alone and parsing followed by
+serialization. Start with the narrowest mode that covers the change:
+
+```bash
+# Parser throughput on 100 real-world documents, without RSS sampling noise.
+python benchmarks/performance.py --parsers justhtml --iterations 5
+
+# Parse plus default HTML serialization.
+python benchmarks/performance.py --parsers justhtml_to_html --iterations 5
+
+# Compare selected installed parsers on a larger corpus sample.
+python benchmarks/performance.py --parsers justhtml html5lib lxml --limit 1000 --iterations 3
+```
+
+Use `--all-batches` for a corpus-wide measurement, `--batch PATH` for one
+archive, or `--downloaded DIR` for a directory of decompressed-source files.
+The benchmark reports total throughput and per-document timing. Compare the
+same command before and after a change on the same machine; do not compare
+absolute timings across machines.
+
+## Find the hot path
+
+Profile a representative web100k batch before optimizing:
+
+```bash
+python benchmarks/profile.py --mode parse
+```
+
+Available modes are `parse`, `fragment`, `compact-html`, `pretty-html`, and
+`text`. Use the mode closest to the public operation you are improving. Focus
+on functions that dominate cumulative work across many documents, not an
+isolated slow malformed sample.
+
+## Make a speed improvement
+
+- Preserve parser and sanitizer semantics. Run the parser differential suite
+  before relying on a throughput result.
+- Optimize work on the normal path: token scanning, tree construction,
+  attribute projection, and common serialization cases.
+- Prefer direct local data access, reused compiled plans, and fewer temporary
+  allocations in per-character and per-node loops.
+- Measure realistic HTML before and after the change. Include a focused
+  microbenchmark only when it explains the real-world result.
+- Keep benchmarks honest: warm up once, run multiple iterations, and report
+  the exact command, corpus size, and pipeline mode in the pull request.
+
+## Validate and document
+
+Add correctness tests for behavior affected by an optimization. Run the full
+project gate before submitting:
+
+```bash
+pre-commit run --all-files
+```
+
+Update `CHANGELOG.md` with a `Performance` entry that states the affected
+pipeline and the avoided work. If the change also prevents disproportionate
+resource use from hostile input, add a `Security` entry as well.

{justhtml-3.4.0 → justhtml-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: justhtml
-Version: 3.4.0
+Version: 3.6.0
 Summary: A pure Python HTML5 parser that just works.
 Project-URL: Homepage, https://github.com/emilstenstrom/justhtml
 Project-URL: Issues, https://github.com/emilstenstrom/justhtml/issues
@@ -40,8 +40,8 @@ Requires-Dist: html5-parser; extra == 'benchmark'
 Requires-Dist: html5lib; extra == 'benchmark'
 Requires-Dist: lxml; extra == 'benchmark'
 Requires-Dist: markupever; extra == 'benchmark'
-Requires-Dist: psutil; extra == 'benchmark'
 Requires-Dist: selectolax>=0.4.8; extra == 'benchmark'
+Requires-Dist: turbohtml>=1.3.1; extra == 'benchmark'
 Requires-Dist: zstandard; extra == 'benchmark'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'

{justhtml-3.4.0 → justhtml-3.6.0}/SECURITY.md

@@ -26,6 +26,11 @@ bytes, and HTML-derived values supplied to parsing, sanitization, and
 serialization APIs. The promises below apply when callers use the documented
 safe defaults or a deliberately safe policy.
 
+Availability is part of that boundary. Small hostile inputs must not trigger
+disproportionate work or uncaught conversion errors while parsing, sanitizing,
+transforming, or serializing. Applications still need their own limits for
+total input size, execution time, and memory use.
+
 Library configuration is trusted application code. This includes custom
 sanitization policies, transform specifications and callbacks, selectors,
 glob patterns, CLI flags, and any policy or transform values assembled from
@@ -56,7 +61,8 @@ Promise:
 - JustHTML decodes bytes using HTML-style encoding detection and rejects UTF-7.
 - JustHTML parses malformed HTML into a DOM using browser-style HTML5 recovery.
 - The parser handles entity and character-reference edge cases.
-- The parser avoids known small-input patterns that can cause excessive work.
+- The parser avoids known small-input patterns that can cause excessive work or
+  uncaught conversion errors.
 - JustHTML reports parse errors as data unless strict mode is enabled.
 - Fragment parsing and full-document parsing keep their different assumptions
   explicit.
@@ -140,6 +146,8 @@ Promise:
 - Serialization rejects unsafe element and attribute names created through
   custom DOM changes.
 - Serialization neutralizes rawtext end-tag sequences.
+- Pretty serialization bounds indentation and avoids repeatedly copying nested
+  output, so deeply nested input does not cause disproportionate work.
 - `to_text()` returns text content rather than markup.
 - `to_markdown()` escapes Markdown-sensitive text by default.
 - `to_markdown()` escapes line-start Markdown markers that could change block
@@ -179,6 +187,8 @@ Promise:
   sanitization step after later transforms.
 - Built-in URL-aware transforms reuse sanitizer URL cleaning where they can.
 - Linkification operates on DOM text nodes rather than raw HTML strings.
+- Built-in structural transforms avoid repeated sibling-list shifting for
+  common bulk operations on untrusted documents.
 
 Out of scope:
 - Safety of arbitrary user callbacks passed to transform APIs.

{justhtml-3.4.0 → justhtml-3.6.0}/benchmarks/correctness.py

@@ -22,7 +22,17 @@ from justhtml.parser.context import FragmentContext
 from justhtml.serializer import to_test_format
 
 # Available parsers
-PARSERS = ["justhtml", "html5lib", "html5_parser", "lxml", "bs4", "html.parser", "selectolax", "markupever"]
+PARSERS = [
+    "justhtml",
+    "html5lib",
+    "html5_parser",
+    "lxml",
+    "bs4",
+    "html.parser",
+    "selectolax",
+    "markupever",
+    "turbohtml",
+]
 
 
 class Status(Enum):
@@ -61,6 +71,7 @@ PARSER_CAPABILITIES = {
     "html.parser": ParserCapabilities(),
     "selectolax": ParserCapabilities(fragment_context=True, foreign_fragment_context=True),
     "markupever": ParserCapabilities(),
+    "turbohtml": ParserCapabilities(fragment_context=True, foreign_fragment_context=True),
 }
 
 
@@ -146,6 +157,15 @@ def check_parser_available(parser_name):
             return True
         except ImportError:
             return False
+    if parser_name == "turbohtml":
+        try:
+            from turbohtml import parse, parse_fragment
+
+            parse("<p></p>")
+            parse_fragment("<p></p>", "div")
+            return True
+        except (ImportError, TypeError, ValueError, AttributeError):
+            return False
     return False
 
 
@@ -174,6 +194,33 @@ def parse_dat_file(path):
     return tests
 
 
+def decode_escapes(text):
+    """Decode the \"\\xXX\" and \"\\uXXXX\" sequences used by tree fixtures."""
+    if "\\x" not in text and "\\u" not in text:
+        return text
+
+    result = []
+    i = 0
+    while i < len(text):
+        if text[i : i + 2] == "\\x" and i + 3 < len(text):
+            try:
+                result.append(chr(int(text[i + 2 : i + 4], 16)))
+                i += 4
+                continue
+            except ValueError:
+                pass
+        elif text[i : i + 2] == "\\u" and i + 5 < len(text):
+            try:
+                result.append(chr(int(text[i + 2 : i + 6], 16)))
+                i += 6
+                continue
+            except ValueError:
+                pass
+        result.append(text[i])
+        i += 1
+    return "".join(result)
+
+
 def parse_single_test(lines):
     """Parse a single test from lines."""
     data = []
@@ -209,7 +256,7 @@ def parse_single_test(lines):
 
     if data or document:
         return {
-            "data": "\n".join(data),
+            "data": decode_escapes("\n".join(data)),
             "document": "\n".join(document),
             "fragment_context": fragment_context,
             "script_directive": script_directive,
@@ -502,6 +549,23 @@ def run_test_markupever(html, fragment_context, expected, xml_coercion=False, if
         return _error(e)
 
 
+def run_test_turbohtml(html, fragment_context, expected, xml_coercion=False, iframe_srcdoc=False):
+    """Run a single test with TurboHTML's public DOM API."""
+    from turbohtml import parse, parse_fragment
+
+    try:
+        if fragment_context:
+            namespace, tag_name = fragment_context
+            context = f"{namespace} {tag_name}" if namespace else tag_name
+            node = parse_fragment(html, context)
+            actual = _turbohtml_to_test_format(node.children, 0)
+        else:
+            actual = _turbohtml_to_test_format(parse(html).children, 0)
+        return _compare_result(expected, actual)
+    except Exception as e:
+        return _error(e)
+
+
 # =============================================================================
 # Test format conversion helpers
 # =============================================================================
@@ -839,6 +903,56 @@ def _markupever_to_test_format(nodes):
     return "".join(line for node in nodes for line in process(node, 0))
 
 
+def _turbohtml_to_test_format(nodes, indent):
+    """Convert TurboHTML's public node objects to html5lib test format."""
+    from turbohtml import Comment, Doctype, Element, Namespace, Text
+
+    def qualified_name(namespace, name):
+        if namespace is Namespace.SVG:
+            return f"svg {name}"
+        if namespace is Namespace.MATHML:
+            return f"math {name}"
+        return name
+
+    def attribute_name(name):
+        if name.startswith("xlink:"):
+            return f"xlink {name.removeprefix('xlink:')}"
+        if name.startswith("xml:"):
+            return f"xml {name.removeprefix('xml:')}"
+        if name.startswith("xmlns:"):
+            return f"xmlns {name.removeprefix('xmlns:')}"
+        return name
+
+    def process(node, node_indent):
+        prefix = " " * node_indent
+        if isinstance(node, Doctype):
+            if node.public_id is not None or node.system_id is not None:
+                public_id = node.public_id or ""
+                system_id = node.system_id or ""
+                return [f'| <!DOCTYPE {node.name} "{public_id}" "{system_id}">']
+            return [f"| <!DOCTYPE {node.name}>"]
+        if isinstance(node, Comment):
+            return [f"| {prefix}<!-- {node.data} -->"]
+        if isinstance(node, Text):
+            return [f'| {prefix}"{node.text}"']
+        if not isinstance(node, Element):
+            return [line for child in node.children for line in process(child, node_indent)]
+
+        lines = [f"| {prefix}<{qualified_name(node.namespace, node.tag)}>"]
+        for name, value in sorted(node.attrs.items()):
+            lines.append(f'| {prefix}  {attribute_name(name)}="{value}"')
+
+        if node.tag == "template" and node.namespace is Namespace.HTML:
+            lines.append(f"| {prefix}  content")
+            content = node.children[0]
+            lines.extend(line for child in content.children for line in process(child, node_indent + 4))
+        else:
+            lines.extend(line for child in node.children for line in process(child, node_indent + 2))
+        return lines
+
+    return "\n".join(line for node in nodes for line in process(node, indent))
+
+
 # Parser dispatch
 PARSER_RUNNERS = {
     "justhtml": run_test_justhtml,
@@ -849,6 +963,7 @@ PARSER_RUNNERS = {
     "html.parser": run_test_html_parser,
     "selectolax": run_test_selectolax,
     "markupever": run_test_markupever,
+    "turbohtml": run_test_turbohtml,
 }