justhtml 3.11.0__tar.gz → 3.11.2__tar.gz

{justhtml-3.11.0 → justhtml-3.11.2}/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.11.2] - 2026-08-27
+
+### Fixed
+
+- Preserve content following closed `script` or `style` elements in dropped SVG and MathML subtrees when parsing
+  fragments with a custom sanitization policy.
+- WPT update: Foster invalid row content correctly when a disallowed template appears inside a table.
+
+## [3.11.1] - 2026-08-16
+
+### Fixed
+
+- Preserve rendered word separation when pretty HTML serialization normalizes a newline next to an inline element.
+
 ## [3.11.0] - 2026-08-07
 
 ### Performance

{justhtml-3.11.0 → justhtml-3.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: justhtml
-Version: 3.11.0
+Version: 3.11.2
 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

{justhtml-3.11.0 → justhtml-3.11.2}/benchmarks/correctness.py

@@ -16,6 +16,7 @@ import sys
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
+from typing import Final
 
 from justhtml import JustHTML
 from justhtml.parser.context import FragmentContext
@@ -577,6 +578,19 @@ NS_MATHML = "http://www.w3.org/1998/Math/MathML"
 NS_XLINK = "http://www.w3.org/1999/xlink"
 NS_XML = "http://www.w3.org/XML/1998/namespace"
 NS_XMLNS = "http://www.w3.org/2000/xmlns/"
+_TURBOHTML_FOREIGN_ATTRIBUTE_NAMES: Final[dict[str, str]] = {
+    "xlink:actuate": "xlink actuate",
+    "xlink:arcrole": "xlink arcrole",
+    "xlink:href": "xlink href",
+    "xlink:role": "xlink role",
+    "xlink:show": "xlink show",
+    "xlink:title": "xlink title",
+    "xlink:type": "xlink type",
+    "xml:lang": "xml lang",
+    "xml:space": "xml space",
+    "xmlns": "xmlns xmlns",
+    "xmlns:xlink": "xmlns xlink",
+}
 
 
 def _serialize_lxml_document_siblings(root, etree):
@@ -914,14 +928,15 @@ def _turbohtml_to_test_format(nodes, indent):
             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 attribute_name(namespace, name):
+        if namespace not in {Namespace.SVG, Namespace.MATHML}:
+            return name
+        return _TURBOHTML_FOREIGN_ATTRIBUTE_NAMES.get(name, name)
+
+    def attribute_value(value):
+        if isinstance(value, list):
+            return " ".join(value)
+        return value or ""
 
     def process(node, node_indent):
         prefix = " " * node_indent
@@ -939,8 +954,10 @@ def _turbohtml_to_test_format(nodes, indent):
             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}"')
+        for name, value in sorted(
+            (attribute_name(node.namespace, name), attribute_value(value)) for name, value in node.attrs.items()
+        ):
+            lines.append(f'| {prefix}  {name}="{value}"')
 
         if node.tag == "template" and node.namespace is Namespace.HTML:
             lines.append(f"| {prefix}  content")

{justhtml-3.11.0 → justhtml-3.11.2}/docs/comparison.md

@@ -13,7 +13,7 @@ Use a different tool when one narrow requirement matters more than the whole pip
 | **JustHTML**<br>Pure Python | ✅ 100% | ⚡ Fast | ✅ CSS selectors | ✅ `element()` | ✅ Built-in | Correct, secure, easy to install, and fast enough. |
 | **`selectolax`**<br>Python wrapper of C-based Lexbor | ✅ 100% | 🚀 Very Fast | ✅ CSS selectors | ✅ `create_node()` | ❌ Needs sanitization | Very fast. |
 | **Chromium**<br>browser engine | 🟡 95.0% [2] | 🚀 Very Fast | — | — | — | Current browser-harness result. |
-| **`turbohtml`**<br>Python wrapper of a C core | 🟡 94.2% | 🚀 Very Fast | ✅ CSS selectors, XPath | ✅ `E.*` builder | ✅ Built-in | Broad, compiled alternative with parsing, querying, and sanitization. |
+| **`turbohtml`**<br>Python wrapper of a C core | 🟡 94.8% | 🚀 Very Fast | ✅ CSS selectors, XPath | ✅ `E.*` builder | ✅ Built-in | Broad, compiled alternative with parsing, querying, and sanitization. |
 | **WebKit**<br>browser engine | 🟡 93.9% [2] | 🚀 Very Fast | — | — | — | Current browser-harness result. |
 | **Firefox**<br>browser engine | 🟡 93.1% [2] | 🚀 Very Fast | — | — | — | Current browser-harness result. |
 | **`html5lib`**<br>Pure Python | 🟡 82.3% | 🐢 Slow | 🟡 XPath (lxml) | 🟡 Tree API | 🔴 [Deprecated](https://github.com/html5lib/html5lib-python/issues/443) | Unmaintained reference implementation; incomplete coverage of the tree-construction fixtures. |

{justhtml-3.11.0 → justhtml-3.11.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "justhtml"
 authors = [{ name = "Emil Stenström", email = "emil@emilstenstrom.se" }]
-version = "3.11.0"
+version = "3.11.2"
 description = "A pure Python HTML5 parser that just works."
 readme = "README.md"
 license = { file = "LICENSE" }

{justhtml-3.11.0 → justhtml-3.11.2}/src/justhtml/parser/engine.py

@@ -1435,8 +1435,7 @@ class ParseEngine:
             # rules, which may splice a form or run adoption, rather than
             # popping the foreign elements sitting above it.
             return False
-        if self._track_tag_spans:
-            self._set_end_span(node, name, tag_start, tag_end)
+        self._set_end_span(node, name, tag_start, tag_end)
         del stack[target_index:]
         return True
 
@@ -5250,14 +5249,22 @@ class ParseEngine:
         ):  # pragma: no branch - opposite edge requires invalid parser state
             return None  # pragma: no cover - unreachable after parser-state guards
         table_idx = self._find_open_index("table")
-        # Fostering runs once per node placed inside a table, and no template is
-        # open for the overwhelming majority of them. Both counters below are
-        # maintained anyway, so consulting them skips two stack lookups.
         parser_only_template_idx = (
             self._open_parser_only_template_index() if self._parser_only_template_depth else None
         )
-        if table_idx is not None and parser_only_template_idx is not None and table_idx < parser_only_template_idx:
+        # A parser-only template projects direct children into its rendered
+        # table parent. Descendants of those children still foster within the
+        # projected template contents, for example a <div> inside a <tr>.
+        if (
+            table_idx is not None
+            and parser_only_template_idx is not None
+            and table_idx < parser_only_template_idx
+            and self._stack[table_idx] is parent
+        ):
             return None
+        # Fostering runs once per node placed inside a table, and no template is
+        # open for the overwhelming majority of them. Both counters below are
+        # maintained anyway, so consulting them skips two stack lookups.
         template_idx = self._open_template_index() if self._template_modes else None
         if table_idx is not None and template_idx is not None and table_idx < template_idx:
             table_idx = None

{justhtml-3.11.0 → justhtml-3.11.2}/src/justhtml/serializer/html.py

@@ -495,7 +495,12 @@ def _collapse_html_whitespace(text: str) -> str:
     return " ".join(text.split())
 
 
-def _normalize_formatting_whitespace(text: str) -> str:
+def _normalize_formatting_whitespace(
+    text: str,
+    *,
+    preserve_leading: bool = False,
+    preserve_trailing: bool = False,
+) -> str:
     """Normalize formatting whitespace within a text node.
 
     Converts newlines/tabs/CR/FF to regular spaces and collapses runs that
@@ -543,9 +548,9 @@ def _normalize_formatting_whitespace(text: str) -> str:
         out.append(ch)
 
     normalized = "".join(out)
-    if starts_with_formatting and normalized.startswith(" "):
+    if starts_with_formatting and normalized.startswith(" ") and not preserve_leading:
         normalized = normalized[1:]
-    if ends_with_formatting and normalized.endswith(" "):
+    if ends_with_formatting and normalized.endswith(" ") and not preserve_trailing:
         normalized = normalized[:-1]
     return normalized
 
@@ -1025,14 +1030,23 @@ def _node_to_html(node: Any, indent: int = 0, indent_size: int = 2, *, in_pre: b
                                 continue
 
                             parts_template: list[tuple[str, Any]] = []
-                            for child in run:
+                            for run_index, child in enumerate(run):
                                 if child.name == "#text":
                                     data = child.data or ""
                                     if not data.strip():
                                         parts_template.append(("lit", data))
                                     else:
                                         parts_template.append(
-                                            ("lit", _escape_text(_normalize_formatting_whitespace(data)))
+                                            (
+                                                "lit",
+                                                _escape_text(
+                                                    _normalize_formatting_whitespace(
+                                                        data,
+                                                        preserve_leading=run_index > 0,
+                                                        preserve_trailing=run_index < len(run) - 1,
+                                                    )
+                                                ),
+                                            )
                                         )
                                     continue
 
@@ -1115,7 +1129,18 @@ def _node_to_html(node: Any, indent: int = 0, indent_size: int = 2, *, in_pre: b
                                             inline_parts.append(("lit", data))
                                         continue
 
-                                    inline_parts.append(("lit", _escape_text(_normalize_formatting_whitespace(data))))
+                                    inline_parts.append(
+                                        (
+                                            "lit",
+                                            _escape_text(
+                                                _normalize_formatting_whitespace(
+                                                    data,
+                                                    preserve_leading=i != first_non_none_index,
+                                                    preserve_trailing=i != last_non_none_index,
+                                                )
+                                            ),
+                                        )
+                                    )
                                     continue
 
                                 if _is_layout_blocky_element(child, memo):
@@ -1249,7 +1274,11 @@ def _node_to_html(node: Any, indent: int = 0, indent_size: int = 2, *, in_pre: b
                             if "\n" in data or "\r" in data or "\t" in data or len(data) > 2:
                                 compact_parts_template.append(("lit", " "))
                                 continue
-                        data = _normalize_formatting_whitespace(data)
+                        data = _normalize_formatting_whitespace(
+                            data,
+                            preserve_leading=i != first_non_none_index,
+                            preserve_trailing=i != last_non_none_index,
+                        )
                         compact_parts_template.append(("lit", _escape_text(data)))
                         continue
 

{justhtml-3.11.0 → justhtml-3.11.2}/tests/test_parser_engine.py

@@ -1451,6 +1451,10 @@ class TestParserRecoveryRegressions(_ParserEngineTestCase):
         default_cases = [
             ("<script>x", "<html><head></head><body></body></html>"),
             ("<table><template>x</table></template>", "<html><head></head><body><table>x</table></body></html>"),
+            (
+                "<table><template><tr><div></div></tr></template>",
+                "<html><head></head><body><table><tr></tr><div></div></table></body></html>",
+            ),
             ("<svg><noframes>x</svg></noframes>", "<html><head></head><body></body></html>"),
             ("<template><colgroup>x</colgroup></template>", "<html><head></head><body></body></html>"),
             ("<table><colgroup>x</table></colgroup>", "<html><head></head><body>x<table></table></body></html>"),

{justhtml-3.11.0 → justhtml-3.11.2}/tests/test_sanitize.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import unittest
+from dataclasses import replace
 
 import justhtml
 from justhtml import JustHTML, Sanitize, SetAttrs
@@ -355,6 +356,40 @@ class TestSanitizePlumbing(unittest.TestCase):
 
 
 class TestSanitizeDom(unittest.TestCase):
+    def test_custom_policy_preserves_content_after_closed_foreign_rawtext(self) -> None:
+        policies = (
+            replace(DEFAULT_POLICY),
+            SanitizationPolicy(
+                allowed_tags={"p"},
+                allowed_attributes={"p": set()},
+                url_policy=UrlPolicy(allow_rules={}),
+            ),
+        )
+
+        for policy in policies:
+            for foreign_tag in ("math", "svg"):
+                for rawtext_tag in ("script", "style"):
+                    html = f"<{foreign_tag}><{rawtext_tag}></{rawtext_tag}></{foreign_tag}>tail<p>end</p>"
+                    with self.subTest(policy=policy, foreign_tag=foreign_tag, rawtext_tag=rawtext_tag):
+                        assert JustHTML(html, fragment=True, policy=policy).to_html(pretty=False) == "tail<p>end</p>"
+                        assert (
+                            JustHTML(
+                                html,
+                                fragment=True,
+                                transforms=[Sanitize(policy=policy)],
+                            ).to_html(pretty=False)
+                            == "tail<p>end</p>"
+                        )
+
+    def test_custom_policy_drops_content_after_unclosed_foreign_rawtext(self) -> None:
+        policy = replace(DEFAULT_POLICY)
+
+        for foreign_tag in ("math", "svg"):
+            for rawtext_tag in ("script", "style"):
+                html = f"<{foreign_tag}><{rawtext_tag}>unsafe</{foreign_tag}>tail<p>end</p>"
+                with self.subTest(foreign_tag=foreign_tag, rawtext_tag=rawtext_tag):
+                    assert JustHTML(html, fragment=True, policy=policy).to_html(pretty=False) == ""
+
     def test_sanitize_dom_document_fragment(self) -> None:
         root = DocumentFragment()
         root.append_child(Node("script"))

{justhtml-3.11.0 → justhtml-3.11.2}/tests/test_serialize.py

@@ -820,6 +820,16 @@ class TestSerialize(unittest.TestCase):
         rendered_text = JustHTML(pretty_html).to_text(separator="", strip=False)
         assert rendered_text == "BApplication(const char* signature);"
 
+    def test_pretty_print_preserves_formatting_whitespace_before_inline_element(self):
+        doc = JustHTML("<p>hello\n<code>world</code></p>", fragment=True)
+
+        assert doc.to_html() == "<p>hello <code>world</code></p>"
+
+    def test_pretty_print_preserves_formatting_whitespace_after_inline_element(self):
+        doc = JustHTML("<p><code>hello</code>\nworld</p>", fragment=True)
+
+        assert doc.to_html() == "<p><code>hello</code> world</p>"
+
     def test_empty_attributes(self):
         html = "<input disabled>"
         doc = JustHTML(html)