justhtml 2.2.0__tar.gz → 2.4.0__tar.gz

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

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-06-20
+
+### Fixed
+- Handle `<hr>` using the HTML in-body void-element rules in delegated insertion modes, preserving following content in table cells and captions, closing open paragraphs, and acknowledging self-closing syntax.
+
+## [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.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: justhtml
-Version: 2.2.0
+Version: 2.4.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
@@ -88,6 +88,8 @@ JustHTML is for applications that want a boring, inspectable, pure-Python defaul
 - **Easy deployment:** zero runtime dependencies, no compiler, works on PyPy and Pyodide.
 - **Honest tradeoff:** if you are parsing terabytes of trusted HTML, use a C/Rust parser. If you need reliable handling of untrusted or malformed HTML inside a Python app, use JustHTML.
 
+Real-world signal: [Mozilla Support migrated from Bleach to JustHTML](https://github.com/mozilla/kitsune/pull/7236) in Kitsune, the Django application behind support.mozilla.org.
+
 ## Quick Start
 
 ```python

{justhtml-2.2.0 → justhtml-2.4.0}/README.md

@@ -34,6 +34,8 @@ JustHTML is for applications that want a boring, inspectable, pure-Python defaul
 - **Easy deployment:** zero runtime dependencies, no compiler, works on PyPy and Pyodide.
 - **Honest tradeoff:** if you are parsing terabytes of trusted HTML, use a C/Rust parser. If you need reliable handling of untrusted or malformed HTML inside a Python app, use JustHTML.
 
+Real-world signal: [Mozilla Support migrated from Bleach to JustHTML](https://github.com/mozilla/kitsune/pull/7236) in Kitsune, the Django application behind support.mozilla.org.
+
 ## Quick Start
 
 ```python

{justhtml-2.2.0 → justhtml-2.4.0}/docs/bleach-migration.md

@@ -10,6 +10,107 @@ In 2023, Bleach’s maintainer announced that **Bleach is deprecated** (but will
 
 This guide covers common migration patterns.
 
+## Real-world migration pattern: add a local wrapper first
+
+A large application migration often works best in two steps:
+
+1. Add a small application-local `clean(...)` wrapper that accepts the Bleach-shaped options your codebase already uses.
+2. Migrate call sites from `bleach.clean(...)` / `bleach.linkify(...)` to that wrapper.
+
+That keeps most call-site changes mechanical while leaving the security policy in one place.
+
+Example wrapper:
+
+```python
+import re
+from collections.abc import Collection, Mapping
+
+from justhtml import JustHTML, Linkify, SanitizationPolicy, SetAttrs, UrlPolicy, UrlRule
+
+URL_LIKE_ATTRS = {
+    "href",
+    "src",
+    "srcset",
+    "poster",
+    "action",
+    "formaction",
+    "data",
+    "cite",
+    "background",
+    "ping",
+}
+
+
+def build_url_policy(
+    allowed_tags: Collection[str],
+    allowed_attributes: Mapping[str, Collection[str]],
+) -> UrlPolicy:
+    rules = {}
+
+    global_attrs = allowed_attributes.get("*", ())
+    for tag in allowed_tags:
+        for attr in global_attrs:
+            if attr in URL_LIKE_ATTRS:
+                rules[(tag, attr)] = UrlRule(
+                    allowed_schemes={"http", "https", "mailto", "tel"},
+                    allow_relative=True,
+                )
+
+    for tag, attrs in allowed_attributes.items():
+        if tag == "*":
+            continue
+        for attr in attrs:
+            if attr in URL_LIKE_ATTRS:
+                rules[(tag, attr)] = UrlRule(
+                    allowed_schemes={"http", "https", "mailto", "tel"},
+                    allow_relative=True,
+                )
+    return UrlPolicy(allow_rules=rules)
+
+
+def clean(
+    html: str,
+    *,
+    tags: Collection[str] = (),
+    attributes: Mapping[str, Collection[str]] | None = None,
+    css_properties: Collection[str] = (),
+    strip: bool = True,
+    strip_comments: bool = True,
+) -> str:
+    attrs = dict(attributes or {})
+    disallowed_tag_handling = "unwrap" if strip else "escape"
+
+    # Bleach defaults to strip_comments=True. If you use escape mode
+    # (`strip=False`) and still want comments removed rather than displayed,
+    # remove comments before parsing.
+    if strip_comments and disallowed_tag_handling == "escape":
+        html = re.sub(r"<!--.*?-->", "", html, flags=re.DOTALL)
+
+    policy = SanitizationPolicy(
+        allowed_tags=tags,
+        allowed_attributes=attrs,
+        allowed_css_properties=css_properties,
+        url_policy=build_url_policy(tags, attrs),
+        drop_comments=strip_comments,
+        disallowed_tag_handling=disallowed_tag_handling,
+    )
+    return JustHTML(html, fragment=True, policy=policy).to_html(pretty=False)
+
+
+def linkify(text: str, *, nofollow: bool = False) -> str:
+    transforms = [Linkify()]
+    if nofollow:
+        transforms.append(SetAttrs("a", rel="nofollow"))
+    return JustHTML(
+        text,
+        fragment=True,
+        sanitize=False,
+        transforms=transforms,
+    ).to_html(pretty=False)
+```
+
+Treat this as a compatibility shim, not a universal policy. Tighten `build_url_policy(...)` for your application, especially for attributes that load remote resources such as `img[src]`.
+
 ## Mental model differences
 
 - Bleach takes a string and returns a cleaned string.
@@ -97,6 +198,7 @@ print(doc.to_html(pretty=False))
 Bleach’s `protocols=[...]` concept maps to JustHTML’s URL policy rules.
 
 - Configure allowed schemes per attribute via `UrlRule(allowed_schemes=[...])`.
+- URL-like attributes need explicit `(tag, attr)` allow rules even when the attribute itself is allowed.
 - Under `sanitize=True`, URLs can be rewritten or stripped according to policy (see [URL Cleaning](url-cleaning.md)).
 
 ## What to do with “strip=True/False”
@@ -118,9 +220,20 @@ If you need to display untrusted HTML with no HTML in the output, prefer `to_tex
 
 If you need additional structural cleanup beyond policy decisions, prefer doing it explicitly with transforms.
 
+## Migration test expectations
+
+Expect some output differences even when the security behavior is equivalent:
+
+- Inline styles may be normalized, for example `vertical-align:top;` can serialize as `vertical-align: top`.
+- Malformed HTML can serialize differently because JustHTML parses with its own HTML5 tree builder.
+- `strip=False` maps to escaped disallowed tags. If your old Bleach call also relied on `strip_comments=True`, add an explicit test for comments.
+- Linkification should be tested separately from sanitization when your old code used both `bleach.linkify(...)` and `bleach.clean(...)`.
+
 ## Suggested migration approach
 
-1. Start by using JustHTML’s default sanitizer (`JustHTML(...).to_html()`).
-2. Add a `SanitizationPolicy` that matches your allowlist and URL requirements.
-3. Add transforms to replace any Bleach filter/linkify behavior.
-4. Add tests for your exact input corpus and output expectations (especially around URLs and allowed attributes).
+1. Inventory existing `bleach.clean(...)`, `bleach.Cleaner(...)`, and `bleach.linkify(...)` call shapes.
+2. For a large app, add a local compatibility wrapper so most call sites can move mechanically.
+3. Start by using JustHTML’s default sanitizer (`JustHTML(...).to_html()`) for new code.
+4. Add a `SanitizationPolicy` that matches your allowlist and URL requirements.
+5. Add transforms to replace any Bleach filter/linkify behavior.
+6. Add tests for your exact input corpus and output expectations (especially around URLs, allowed attributes, comments, and malformed HTML).

{justhtml-2.2.0 → justhtml-2.4.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.4.0"
 description = "A pure Python HTML5 parser that just works."
 readme = "README.md"
 license = { file = "LICENSE" }

{justhtml-2.2.0 → justhtml-2.4.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.4.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.4.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.4.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