justhtml 2.2.0__tar.gz → 2.3.0__tar.gz

{justhtml-2.2.0 → justhtml-2.3.0}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.3.0] - 2026-06-12
+
+### Fixed
+- Preserve pretty-printed paragraph line breaks when sanitization is disabled and comments are present in block containers.
+
+### Performance
+- Speed up tree construction scope checks by tracking open elements for common scoped element names.
+
+### Changed
+- Refactor tree-builder open-element bookkeeping and active-formatting entries without changing the public API.
+
 ## [2.2.0] - 2026-06-07
 
 ### Fixed

{justhtml-2.2.0 → justhtml-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: justhtml
-Version: 2.2.0
+Version: 2.3.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

{justhtml-2.2.0 → justhtml-2.3.0}/pyproject.toml

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

{justhtml-2.2.0 → justhtml-2.3.0}/run_tests.py

@@ -194,6 +194,7 @@ def _run_unit_tests(config):
             self._test_counter = 0
             self._test_to_index: dict[str, int] = {}
             self.test_indices: list[tuple[str, int]] = []
+            self._failed_test_ids: set[str] = set()
 
         def startTest(self, test):  # noqa: N802 - unittest API
             super().startTest(test)
@@ -211,10 +212,22 @@ def _run_unit_tests(config):
 
         def addFailure(self, test, err):  # noqa: N802 - unittest API
             super().addFailure(test, err)
+            self._failed_test_ids.add(test.id())
             self.test_indices.append(("fail", self._idx(test)))
 
         def addError(self, test, err):  # noqa: N802 - unittest API
             super().addError(test, err)
+            self._failed_test_ids.add(test.id())
+            self.test_indices.append(("fail", self._idx(test)))
+
+        def addSubTest(self, test, subtest, err):  # noqa: N802 - unittest API
+            super().addSubTest(test, subtest, err)
+            if err is None:
+                return
+            test_id = test.id()
+            if test_id in self._failed_test_ids:
+                return
+            self._failed_test_ids.add(test_id)
             self.test_indices.append(("fail", self._idx(test)))
 
         def addSkip(self, test, reason):  # noqa: N802 - unittest API

{justhtml-2.2.0 → justhtml-2.3.0}/src/justhtml/parser/__init__.py

@@ -156,6 +156,7 @@ class JustHTML:
             iframe_srcdoc=iframe_srcdoc,
             collect_errors=should_collect,
             scripting_enabled=scripting_enabled,
+            track_node_locations=bool(track_node_locations),
             track_tag_spans=track_tag_spans,
         )
         opts = _tokenizer_opts.copy() if _tokenizer_opts is not None else TokenizerOpts()

{justhtml-2.2.0 → justhtml-2.3.0}/src/justhtml/serializer/html.py

@@ -756,7 +756,7 @@ def _node_to_html(node: Any, indent: int = 0, indent_size: int = 2, *, in_pre: b
                 for child in children:
                     if child is None:
                         continue
-                    if child.name == "#comment" or (child.name == "#text" and (child.data or "").strip()):
+                    if child.name == "#text" and (child.data or "").strip():
                         can_indent = False
                         break
 

{justhtml-2.2.0 → justhtml-2.3.0}/src/justhtml/treebuilder/core.py

@@ -54,6 +54,46 @@ class _SelectedContentWalkItem(NamedTuple):
     in_datalist: bool
 
 
+class _FormattingEntry:
+    __slots__ = ("attrs", "name", "node", "signature")
+
+    name: str
+    attrs: dict[str, str | None]
+    node: Any
+    signature: tuple[tuple[str, str], ...]
+
+    def __init__(
+        self,
+        name: str,
+        attrs: dict[str, str | None],
+        node: Any,
+        signature: tuple[tuple[str, str], ...],
+    ) -> None:
+        self.name = name
+        self.attrs = attrs
+        self.node = node
+        self.signature = signature
+
+
+_OPEN_ELEMENT_SCOPE_COUNT_NAMES = frozenset(
+    (
+        "button",
+        "caption",
+        "dd",
+        "dt",
+        "form",
+        "li",
+        "table",
+        "tbody",
+        "td",
+        "tfoot",
+        "th",
+        "thead",
+        "tr",
+    )
+)
+
+
 class TreeBuilder(TreeBuilderModesMixin):
     __slots__ = (
         "_body_end_handlers",
@@ -61,6 +101,8 @@ class TreeBuilder(TreeBuilderModesMixin):
         "_body_token_handlers",
         "_mode_handlers",
         "_open_p_elements",
+        "_open_scope_name_counts",
+        "_open_template_elements",
         "_pending_end_tag_end",
         "_pending_end_tag_name",
         "_pending_end_tag_start",
@@ -88,6 +130,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         "template_modes",
         "tokenizer",
         "tokenizer_state_override",
+        "track_node_locations",
         "track_tag_spans",
     )
 
@@ -98,6 +141,7 @@ class TreeBuilder(TreeBuilderModesMixin):
     _pending_end_tag_name: str | None
     _pending_end_tag_start: int | None
     _pending_end_tag_end: int | None
+    track_node_locations: bool
     track_tag_spans: bool
     active_formatting: list[Any]
     collect_errors: bool
@@ -115,6 +159,8 @@ class TreeBuilder(TreeBuilderModesMixin):
     open_elements: list[Any]
     original_mode: InsertionMode | None  # type: ignore[assignment]
     _open_p_elements: int
+    _open_scope_name_counts: dict[str, int]
+    _open_template_elements: int
     _saw_select_element: bool
     pending_table_text: list[str]
     pending_table_text_should_error: bool
@@ -131,12 +177,14 @@ class TreeBuilder(TreeBuilderModesMixin):
         iframe_srcdoc: bool = False,
         collect_errors: bool = False,
         scripting_enabled: bool = True,
+        track_node_locations: bool = False,
         track_tag_spans: bool = False,
     ) -> None:
         self.fragment_context = fragment_context
         self.iframe_srcdoc = iframe_srcdoc
         self.collect_errors = collect_errors
         self.scripting_enabled = bool(scripting_enabled)
+        self.track_node_locations = bool(track_node_locations)
         self.track_tag_spans = bool(track_tag_spans)
         self.errors = []
         self.tokenizer = None  # Set by parser after tokenizer is created
@@ -150,6 +198,8 @@ class TreeBuilder(TreeBuilderModesMixin):
         self.table_text_original_mode = None
         self.open_elements = []
         self._open_p_elements = 0
+        self._open_scope_name_counts = {}
+        self._open_template_elements = 0
         self._saw_select_element = False
         self._pending_end_tag_name = None
         self._pending_end_tag_start = None
@@ -263,6 +313,8 @@ class TreeBuilder(TreeBuilderModesMixin):
     ) -> bool:
         if target == "p" and self._open_p_elements == 0:
             return False
+        if target in _OPEN_ELEMENT_SCOPE_COUNT_NAMES and self._open_scope_name_counts.get(target, 0) == 0:
+            return False
         if terminators is None:
             terminators = DEFAULT_SCOPE_TERMINATORS
         open_elements = self.open_elements
@@ -294,17 +346,59 @@ class TreeBuilder(TreeBuilderModesMixin):
                 break
 
     def _note_open_element_pushed(self, node: Any) -> None:
-        if node is not None and node.name == "p":
+        if node is None:
+            return
+        name = node.name
+        if name == "p":
             self._open_p_elements += 1
+        elif name == "template":
+            self._open_template_elements += 1
+        elif name in _OPEN_ELEMENT_SCOPE_COUNT_NAMES:
+            self._open_scope_name_counts[name] = self._open_scope_name_counts.get(name, 0) + 1
 
     def _note_open_element_removed(self, node: Any) -> None:
-        if node is not None and node.name == "p":
+        if node is None:
+            return
+        name = node.name
+        if name == "p":
             self._open_p_elements -= 1
+        elif name == "template":
+            self._open_template_elements -= 1
+        elif name in _OPEN_ELEMENT_SCOPE_COUNT_NAMES:
+            count = self._open_scope_name_counts.get(name, 0)
+            if count <= 1:
+                self._open_scope_name_counts.pop(name, None)
+            else:
+                self._open_scope_name_counts[name] = count - 1
 
     def _note_open_elements_removed(self, nodes: list[Any]) -> None:
         for node in nodes:
             self._note_open_element_removed(node)
 
+    def _has_template_on_stack(self) -> bool:
+        return self._open_template_elements > 0
+
+    def _delete_open_element_at(self, index: int) -> None:
+        self._note_open_element_removed(self.open_elements[index])
+        del self.open_elements[index]
+
+    def _replace_open_element_at(self, index: int, node: Any) -> None:
+        self._note_open_element_removed(self.open_elements[index])
+        self.open_elements[index] = node
+        self._note_open_element_pushed(node)
+
+    def _remove_open_element(self, node: Any) -> None:
+        self._note_open_element_removed(node)
+        self.open_elements.remove(node)
+
+    def _insert_open_element_at(self, index: int, node: Any) -> None:
+        self.open_elements.insert(index, node)
+        self._note_open_element_pushed(node)
+
+    def _truncate_open_elements_from(self, index: int) -> None:
+        self._note_open_elements_removed(self.open_elements[index:])
+        del self.open_elements[index:]
+
     def _close_p_element(self) -> bool:
         if self._has_element_in_button_scope("p"):
             self._generate_implied_end_tags("p")
@@ -545,10 +639,11 @@ class TreeBuilder(TreeBuilderModesMixin):
 
     def _append_comment_to_document(self, text: str) -> None:
         node = Comment(data=text)
-        if self.tokenizer is not None and self.tokenizer.track_node_locations:
-            node._origin_pos = self.tokenizer.last_token_start_pos
+        tokenizer = self.tokenizer
+        if self.track_node_locations and tokenizer is not None:
+            node._origin_pos = tokenizer.last_token_start_pos
             if node._origin_pos is not None:
-                node._origin_line, node._origin_col = self.tokenizer.location_at_pos(node._origin_pos)
+                node._origin_line, node._origin_col = tokenizer.location_at_pos(node._origin_pos)
         self.document.append_child(node)
 
     def _append_comment(self, text: str, parent: Any | None = None) -> None:
@@ -558,10 +653,11 @@ class TreeBuilder(TreeBuilderModesMixin):
         if type(parent) is Template and parent.template_content:
             parent = parent.template_content
         node = Comment(data=text)
-        if self.tokenizer is not None and self.tokenizer.track_node_locations:
-            node._origin_pos = self.tokenizer.last_token_start_pos
+        tokenizer = self.tokenizer
+        if self.track_node_locations and tokenizer is not None:
+            node._origin_pos = tokenizer.last_token_start_pos
             if node._origin_pos is not None:
-                node._origin_line, node._origin_col = self.tokenizer.location_at_pos(node._origin_pos)
+                node._origin_line, node._origin_col = tokenizer.location_at_pos(node._origin_pos)
         parent.append_child(node)
 
     def _append_text(self, text: str) -> None:
@@ -591,10 +687,11 @@ class TreeBuilder(TreeBuilderModesMixin):
                     return
 
             node = Text(text)
-            if self.tokenizer is not None and self.tokenizer.track_node_locations:
-                node._origin_pos = self.tokenizer.last_token_start_pos
+            tokenizer = self.tokenizer
+            if self.track_node_locations and tokenizer is not None:
+                node._origin_pos = tokenizer.last_token_start_pos
                 if node._origin_pos is not None:
-                    node._origin_line, node._origin_col = self.tokenizer.location_at_pos(node._origin_pos)
+                    node._origin_line, node._origin_col = tokenizer.location_at_pos(node._origin_pos)
             children.append(node)
             node.parent = target
             return
@@ -615,10 +712,11 @@ class TreeBuilder(TreeBuilderModesMixin):
             return
 
         node = Text(text)
-        if self.tokenizer is not None and self.tokenizer.track_node_locations:
-            node._origin_pos = self.tokenizer.last_token_start_pos
+        tokenizer = self.tokenizer
+        if self.track_node_locations and tokenizer is not None:
+            node._origin_pos = tokenizer.last_token_start_pos
             if node._origin_pos is not None:
-                node._origin_line, node._origin_col = self.tokenizer.location_at_pos(node._origin_pos)
+                node._origin_line, node._origin_col = tokenizer.location_at_pos(node._origin_pos)
         children = parent.children
         if position < len(children):
             children.insert(position, node)
@@ -662,10 +760,11 @@ class TreeBuilder(TreeBuilderModesMixin):
             node._start_tag_end = tag.end_pos
         node._self_closing = tag.self_closing
 
-        if self.tokenizer is not None and self.tokenizer.track_node_locations:
+        tokenizer = self.tokenizer
+        if self.track_node_locations and tokenizer is not None:
             node._origin_pos = tag.start_pos
             if node._origin_pos is not None:
-                node._origin_line, node._origin_col = self.tokenizer.location_at_pos(node._origin_pos)
+                node._origin_line, node._origin_col = tokenizer.location_at_pos(node._origin_pos)
 
         # Fast path for common case: not inserting from table
         if not self.insert_from_table:
@@ -747,9 +846,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             node = self.open_elements[index]
             if node is not None and node.name == name:
                 self._maybe_mark_end_tag(node)
-                removed = self.open_elements[index:]
-                self._note_open_elements_removed(removed)
-                del self.open_elements[index:]
+                self._truncate_open_elements_from(index)
                 return
             index -= 1
 
@@ -772,9 +869,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                     self._parse_error("end-tag-too-early")
                 self._maybe_mark_end_tag(node)
                 # Pop all elements from this node onwards
-                removed = self.open_elements[index:]
-                self._note_open_elements_removed(removed)
-                del self.open_elements[index:]
+                self._truncate_open_elements_from(index)
                 return
 
             # If node is a special element, parse error and ignore the tag
@@ -796,8 +891,7 @@ class TreeBuilder(TreeBuilderModesMixin):
     def _remove_from_open_elements(self, node: Any) -> None:
         index = self.open_elements.index(node)
         self._maybe_mark_end_tag(node)
-        self._note_open_element_removed(node)
-        del self.open_elements[index]
+        self._delete_open_element_at(index)
 
     def _is_special_element(self, node: Any) -> bool:
         if node.namespace not in {None, "html"}:
@@ -809,14 +903,14 @@ class TreeBuilder(TreeBuilderModesMixin):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
                 break
-            if entry["name"] == name:
+            if entry.name == name:
                 return index
         return None
 
     def _find_active_formatting_index_by_node(self, node: Any) -> int | None:
         for index in range(len(self.active_formatting) - 1, -1, -1):
             entry = self.active_formatting[index]
-            if entry is not FORMAT_MARKER and entry["node"] is node:
+            if entry is not FORMAT_MARKER and entry.node is node:
                 return index
         return None
 
@@ -826,6 +920,18 @@ class TreeBuilder(TreeBuilderModesMixin):
     def _attrs_signature(self, attrs: dict[str, str | None]) -> tuple[tuple[str, str], ...]:
         if not attrs:
             return ()
+        if len(attrs) == 1:
+            name, value = next(iter(attrs.items()))
+            return ((name, value or ""),)
+        if len(attrs) == 2:
+            iterator = iter(attrs.items())
+            name1, value1 = next(iterator)
+            name2, value2 = next(iterator)
+            item1 = (name1, value1 or "")
+            item2 = (name2, value2 or "")
+            if name1 <= name2:
+                return (item1, item2)
+            return (item2, item1)
         items: list[tuple[str, str]] = []
         for name, value in attrs.items():
             items.append((name, value or ""))
@@ -839,8 +945,8 @@ class TreeBuilder(TreeBuilderModesMixin):
             if entry is FORMAT_MARKER:
                 matches.clear()
                 continue
-            existing_signature = entry["signature"]
-            if entry["name"] == name and existing_signature == signature:
+            existing_signature = entry.signature
+            if entry.name == name and existing_signature == signature:
                 matches.append(index)
         if len(matches) >= 3:
             return matches[0]
@@ -851,7 +957,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
                 break
-            if entry["name"] == name:
+            if entry.name == name:
                 return True
         return False
 
@@ -860,8 +966,8 @@ class TreeBuilder(TreeBuilderModesMixin):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
                 break
-            if entry["name"] == "a":
-                return entry["node"] not in self.open_elements
+            if entry.name == "a":
+                return entry.node not in self.open_elements
         return False
 
     def _remove_last_active_formatting_by_name(self, name: str) -> None:
@@ -869,7 +975,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
                 break
-            if entry["name"] == name:
+            if entry.name == name:
                 del self.active_formatting[index]
                 return
 
@@ -878,21 +984,13 @@ class TreeBuilder(TreeBuilderModesMixin):
             if self.open_elements[index].name == name:
                 node = self.open_elements[index]
                 self._maybe_mark_end_tag(node)
-                self._note_open_element_removed(node)
-                del self.open_elements[index]
+                self._delete_open_element_at(index)
                 return
 
     def _append_active_formatting_entry(self, name: str, attrs: dict[str, str | None], node: Any) -> None:
         entry_attrs = self._clone_attributes(attrs)
         signature = self._attrs_signature(entry_attrs)
-        self.active_formatting.append(
-            {
-                "name": name,
-                "attrs": entry_attrs,
-                "node": node,
-                "signature": signature,
-            },
-        )
+        self.active_formatting.append(_FormattingEntry(name, entry_attrs, node, signature))
 
     def _clear_active_formatting_up_to_marker(self) -> None:
         while self.active_formatting:
@@ -911,7 +1009,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         if not self.active_formatting:
             return
         last_entry = self.active_formatting[-1]
-        if last_entry is FORMAT_MARKER or last_entry["node"] in self.open_elements:
+        if last_entry is FORMAT_MARKER or last_entry.node in self.open_elements:
             return
 
         index = len(self.active_formatting) - 1
@@ -920,20 +1018,20 @@ class TreeBuilder(TreeBuilderModesMixin):
             if index < 0:
                 break
             entry = self.active_formatting[index]
-            if entry is FORMAT_MARKER or entry["node"] in self.open_elements:
+            if entry is FORMAT_MARKER or entry.node in self.open_elements:
                 index += 1
                 break
         if index < 0:
             index = 0
         while index < len(self.active_formatting):
             entry = self.active_formatting[index]
-            tag = Tag(Tag.START, entry["name"], self._clone_attributes(entry["attrs"]), False)
+            tag = Tag(Tag.START, entry.name, self._clone_attributes(entry.attrs), False)
             new_node = self._insert_element(tag, push=True)
-            if self.tokenizer is not None and self.tokenizer.track_node_locations:
-                new_node._origin_pos = entry["node"].origin_offset
-                new_node._origin_line = entry["node"].origin_line
-                new_node._origin_col = entry["node"].origin_col
-            entry["node"] = new_node
+            if self.track_node_locations:
+                new_node._origin_pos = entry.node.origin_offset
+                new_node._origin_line = entry.node.origin_line
+                new_node._origin_col = entry.node.origin_col
+            entry.node = new_node
             index += 1
 
     def _insert_node_at(self, parent: Any, index: int, node: Any) -> None:
@@ -1263,9 +1361,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                     return ("reprocess", self.mode, token, True)
                 # Otherwise it's a foreign element - pop everything from this point up
                 self._maybe_mark_end_tag(node)
-                removed = self.open_elements[idx:]
-                self._note_open_elements_removed(removed)
-                del self.open_elements[idx:]
+                self._truncate_open_elements_from(idx)
                 return None
 
             # Per HTML5 spec: if first node doesn't match, it's a parse error

{justhtml-2.2.0 → justhtml-2.3.0}/src/justhtml/treebuilder/modes.py

@@ -199,9 +199,7 @@ class TreeBuilderModesMixin:
                 self.template_modes.append(InsertionMode.IN_TEMPLATE)
                 return None
             if token.kind == Tag.END and token.name == "template":
-                # Check if template is on the stack (don't use scope check as table blocks it)
-                has_template = any(node is not None and node.name == "template" for node in self.open_elements)
-                if not has_template:
+                if not self._has_template_on_stack():
                     return None
                 self._generate_implied_end_tags()
                 self._pop_until_inclusive("template")
@@ -357,8 +355,7 @@ class TreeBuilderModesMixin:
                 self.mode = InsertionMode.IN_HEAD
                 return ("reprocess", InsertionMode.IN_HEAD, token)
             if token.kind == Tag.END and token.name == "template":
-                has_template = any(node is not None and node.name == "template" for node in self.open_elements)
-                if not has_template:
+                if not self._has_template_on_stack():
                     self._parse_error("unexpected-end-tag", tag_name=token.name)
                     return None
                 return self._mode_in_head(token)
@@ -617,7 +614,7 @@ class TreeBuilderModesMixin:
                 return
 
             formatting_element_entry = self.active_formatting[formatting_element_index]
-            formatting_element = formatting_element_entry["node"]
+            formatting_element = formatting_element_entry.node
 
             # 4. If formatting element is not in open elements
             if formatting_element not in self.open_elements:
@@ -686,21 +683,18 @@ class TreeBuilderModesMixin:
                     node_formatting_index = None
 
                 if node_formatting_index is None:
-                    self._note_open_element_removed(self.open_elements[node_index])
-                    del self.open_elements[node_index]
+                    self._delete_open_element_at(node_index)
                     continue
 
                 # 10.4 Replace entry with new element
                 entry = self.active_formatting[node_formatting_index]
-                new_element = self._create_element(entry["name"], entry["node"].namespace, entry["attrs"])
-                if self.tokenizer is not None and self.tokenizer.track_node_locations:
-                    new_element._origin_pos = entry["node"].origin_offset
-                    new_element._origin_line = entry["node"].origin_line
-                    new_element._origin_col = entry["node"].origin_col
-                entry["node"] = new_element
-                self._note_open_element_removed(self.open_elements[node_index])
-                self.open_elements[node_index] = new_element
-                self._note_open_element_pushed(new_element)
+                new_element = self._create_element(entry.name, entry.node.namespace, entry.attrs)
+                if self.track_node_locations:
+                    new_element._origin_pos = entry.node.origin_offset
+                    new_element._origin_line = entry.node.origin_line
+                    new_element._origin_col = entry.node.origin_col
+                entry.node = new_element
+                self._replace_open_element_at(node_index, new_element)
                 node = new_element
 
                 # 10.5 If last node is furthest block, update bookmark
@@ -731,12 +725,12 @@ class TreeBuilderModesMixin:
 
             # 12. Create new formatting element
             entry = self.active_formatting[formatting_element_index]
-            new_formatting_element = self._create_element(entry["name"], entry["node"].namespace, entry["attrs"])
-            if self.tokenizer is not None and self.tokenizer.track_node_locations:
-                new_formatting_element._origin_pos = entry["node"].origin_offset
-                new_formatting_element._origin_line = entry["node"].origin_line
-                new_formatting_element._origin_col = entry["node"].origin_col
-            entry["node"] = new_formatting_element
+            new_formatting_element = self._create_element(entry.name, entry.node.namespace, entry.attrs)
+            if self.track_node_locations:
+                new_formatting_element._origin_pos = entry.node.origin_offset
+                new_formatting_element._origin_line = entry.node.origin_line
+                new_formatting_element._origin_col = entry.node.origin_col
+            entry.node = new_formatting_element
 
             # 13. Move children of furthest block
             moved_children = furthest_block.children
@@ -754,11 +748,9 @@ class TreeBuilderModesMixin:
             self.active_formatting.insert(bookmark, entry)
 
             # 15. Remove formatting element from open elements and insert new one
-            self._note_open_element_removed(formatting_element)
-            self.open_elements.remove(formatting_element)
+            self._remove_open_element(formatting_element)
             furthest_block_index = self.open_elements.index(furthest_block)
-            self.open_elements.insert(furthest_block_index + 1, new_formatting_element)
-            self._note_open_element_pushed(new_formatting_element)
+            self._insert_open_element_at(furthest_block_index + 1, new_formatting_element)
 
     def _handle_body_start_a(self, token: Tag) -> None:
         if self._has_active_formatting_entry("a"):
@@ -815,8 +807,7 @@ class TreeBuilderModesMixin:
             return
         body_elem = self.open_elements[body_index]
         body_elem.parent.remove_child(body_elem)
-        self._note_open_elements_removed(self.open_elements[body_index:])
-        self.open_elements = self.open_elements[:body_index]
+        self._truncate_open_elements_from(body_index)
         self._insert_element(token, push=True)
         self.mode = InsertionMode.IN_FRAMESET
         return
@@ -922,8 +913,7 @@ class TreeBuilderModesMixin:
         return
 
     def _handle_body_end_template(self, token: Tag) -> None:
-        has_template = any(node is not None and node.name == "template" for node in self.open_elements)
-        if not has_template:
+        if not self._has_template_on_stack():
             self._parse_error("unexpected-end-tag", tag_name=token.name)
             return
         self._generate_implied_end_tags()
@@ -1716,7 +1706,7 @@ class TreeBuilderModesMixin:
                 if fmt_index is None:
                     self._parse_error("unexpected-end-tag-in-select", tag_name=name)
                     return None
-                target = self.active_formatting[fmt_index]["node"]
+                target = self.active_formatting[fmt_index].node
                 if target in self.open_elements:  # pragma: no branch
                     select_index = self.open_elements.index(select_node)
                     target_index = self.open_elements.index(target)
@@ -1816,9 +1806,7 @@ class TreeBuilderModesMixin:
             }:
                 return self._mode_in_head(token)
         if isinstance(token, EOFToken):
-            # Check if template is on the stack (don't use _in_scope as table blocks it)
-            has_template = any(node is not None and node.name == "template" for node in self.open_elements)
-            if not has_template:
+            if not self._has_template_on_stack():
                 return None
             # Parse error for EOF in template
             self._parse_error("expected-closing-tag-but-got-eof", tag_name="template")

{justhtml-2.2.0 → justhtml-2.3.0}/tests/test_linkify_internals.py

@@ -69,15 +69,19 @@ class TestLinkifyInternals(unittest.TestCase):
     def test_punctuation_runs_do_not_trigger_quadratic_email_scan(self) -> None:
         for ch in ('"', "-", ".", "!"):
             with self.subTest(ch=ch):
+                text = ch * 20_000
+                find_links_with_config(text, LinkifyConfig())
                 start = perf_counter()
-                assert find_links_with_config(ch * 20_000, LinkifyConfig()) == []
+                assert find_links_with_config(text, LinkifyConfig()) == []
                 assert perf_counter() - start < 0.25
 
     def test_unmatched_closing_brackets_do_not_trigger_quadratic_trimming(self) -> None:
         for ch in (")", "]", "}", ">"):
             with self.subTest(ch=ch):
+                text = "http://example.com/" + ch * 20_000
+                find_links_with_config(text, LinkifyConfig())
                 start = perf_counter()
-                out = find_links_with_config("http://example.com/" + ch * 20_000, LinkifyConfig())
+                out = find_links_with_config(text, LinkifyConfig())
                 assert len(out) == 1
                 assert out[0].text == "http://example.com/"
                 assert perf_counter() - start < 0.25