justhtml 0.6.0__py3-none-any.whl → 0.33.0__py3-none-any.whl

justhtml/treebuilder.py

@@ -1,5 +1,8 @@
 # ruff: noqa: S101, PLW2901
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
 
 from .constants import (
     BUTTON_SCOPE_TERMINATORS,
@@ -23,13 +26,16 @@ from .constants import (
 )
 from .errors import generate_error_message
 from .node import ElementNode, SimpleDomNode, TemplateNode, TextNode
-from .tokens import CharacterTokens, CommentToken, DoctypeToken, EOFToken, ParseError, Tag, TokenSinkResult
+from .tokens import AnyToken, CharacterTokens, CommentToken, DoctypeToken, EOFToken, ParseError, Tag, TokenSinkResult
 from .treebuilder_modes import TreeBuilderModesMixin
 from .treebuilder_utils import (
     InsertionMode,
     is_all_whitespace,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 
 class TreeBuilder(TreeBuilderModesMixin):
     __slots__ = (
@@ -53,6 +59,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         "open_elements",
         "original_mode",
         "pending_table_text",
+        "pending_table_text_should_error",
         "quirks_mode",
         "table_text_original_mode",
         "template_modes",
@@ -60,12 +67,39 @@ class TreeBuilder(TreeBuilderModesMixin):
         "tokenizer_state_override",
     )
 
+    _body_end_handlers: dict[str, Callable[[TreeBuilder, Any], Any]]
+    _body_start_handlers: dict[str, Callable[[TreeBuilder, Any], Any]]
+    _body_token_handlers: dict[str, Callable[[TreeBuilder, Any], Any]]
+    _mode_handlers: dict[InsertionMode, Callable[[TreeBuilder, Any], Any]]
+    active_formatting: list[Any]
+    collect_errors: bool
+    document: SimpleDomNode
+    errors: list[ParseError]
+    form_element: Any | None
+    fragment_context: Any | None
+    fragment_context_element: Any | None
+    frameset_ok: bool
+    head_element: Any | None
+    iframe_srcdoc: bool
+    ignore_lf: bool
+    insert_from_table: bool
+    mode: InsertionMode
+    open_elements: list[Any]
+    original_mode: InsertionMode | None  # type: ignore[assignment]
+    pending_table_text: list[str]
+    pending_table_text_should_error: bool
+    quirks_mode: str
+    table_text_original_mode: InsertionMode | None  # type: ignore[assignment]
+    template_modes: list[InsertionMode]
+    tokenizer: Any | None
+    tokenizer_state_override: Any | None  # type: ignore[assignment]
+
     def __init__(
         self,
-        fragment_context=None,
-        iframe_srcdoc=False,
-        collect_errors=False,
-    ):
+        fragment_context: Any | None = None,
+        iframe_srcdoc: bool = False,
+        collect_errors: bool = False,
+    ) -> None:
         self.fragment_context = fragment_context
         self.iframe_srcdoc = iframe_srcdoc
         self.collect_errors = collect_errors
@@ -86,6 +120,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         self.quirks_mode = "no-quirks"
         self.ignore_lf = False
         self.active_formatting = []
+        self.pending_table_text_should_error = False
         self.insert_from_table = False
         self.pending_table_text = []
         self.template_modes = []
@@ -134,10 +169,10 @@ class TreeBuilder(TreeBuilderModesMixin):
             # This prevents frameset from being inserted in fragment contexts
             self.frameset_ok = False
 
-    def _set_quirks_mode(self, mode):
+    def _set_quirks_mode(self, mode: str) -> None:
         self.quirks_mode = mode
 
-    def _parse_error(self, code, tag_name=None, token=None):
+    def _parse_error(self, code: str, tag_name: str | None = None, token: AnyToken | None = None) -> None:
         if not self.collect_errors:
             return
         # Use the position of the last emitted token (set by tokenizer before emit)
@@ -174,13 +209,16 @@ class TreeBuilder(TreeBuilderModesMixin):
                 code,
                 line=line,
                 column=column,
+                category="treebuilder",
                 message=message,
                 source_html=source_html,
                 end_column=end_column,
             )
         )
 
-    def _has_element_in_scope(self, target, terminators=None, check_integration_points=True):
+    def _has_element_in_scope(
+        self, target: str, terminators: set[str] | None = None, check_integration_points: bool = True
+    ) -> bool:
         if terminators is None:
             terminators = DEFAULT_SCOPE_TERMINATORS
         for node in reversed(self.open_elements):
@@ -196,33 +234,33 @@ class TreeBuilder(TreeBuilderModesMixin):
                 return False
         return False
 
-    def _has_element_in_button_scope(self, target):
+    def _has_element_in_button_scope(self, target: str) -> bool:
         return self._has_element_in_scope(target, BUTTON_SCOPE_TERMINATORS)
 
-    def _pop_until_inclusive(self, name):
+    def _pop_until_inclusive(self, name: str) -> None:
         # Callers ensure element exists on stack
         while self.open_elements:  # pragma: no branch
             node = self.open_elements.pop()
             if node.name == name:
                 break
 
-    def _pop_until_any_inclusive(self, names):
+    def _pop_until_any_inclusive(self, names: set[str]) -> None:
         # Pop elements until we find one in names (callers ensure element exists)
         while self.open_elements:
             node = self.open_elements.pop()
             if node.name in names:
                 return
 
-    def _close_p_element(self):
+    def _close_p_element(self) -> bool:
         if self._has_element_in_button_scope("p"):
             self._generate_implied_end_tags("p")
             if self.open_elements[-1].name != "p":
-                self._parse_error("end-tag-too-early", tag_name="p")
+                self._parse_error("unexpected-end-tag", tag_name="p")
             self._pop_until_inclusive("p")
             return True
         return False
 
-    def process_token(self, token):
+    def process_token(self, token: Any) -> Any:
         # Optimization: Use type() identity check instead of isinstance
         token_type = type(token)
         if token_type is DoctypeToken:
@@ -276,7 +314,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                                 self._insert_element(current_token, push=True)
                                 result = None
                             elif name == "p":
-                                result = self._handle_body_start_paragraph(current_token)
+                                result = self._handle_body_start_paragraph(current_token)  # type: ignore[func-returns-value]
                             elif name == "span":
                                 if self.active_formatting:
                                     self._reconstruct_active_formatting_elements()
@@ -284,7 +322,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                                 self.frameset_ok = False
                                 result = None
                             elif name == "a":
-                                result = self._handle_body_start_a(current_token)
+                                result = self._handle_body_start_a(current_token)  # type: ignore[func-returns-value]
                             elif name == "br" or name == "img":
                                 if self.active_formatting:
                                     self._reconstruct_active_formatting_elements()
@@ -331,7 +369,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                             if name == "br":
                                 self._parse_error("unexpected-end-tag", tag_name=name)
                                 br_tag = Tag(0, "br", {}, False)
-                                result = self._handle_body_start_br(br_tag)
+                                result = self._handle_body_start_br(br_tag)  # type: ignore[func-returns-value]
                             elif name in FORMATTING_ELEMENTS:
                                 self._adoption_agency(name)
                                 result = None
@@ -350,7 +388,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                         self._append_text(current_token.data)
                         result = None
                     elif token_type is CommentToken:
-                        result = self._handle_comment_in_body(current_token)
+                        result = self._handle_comment_in_body(current_token)  # type: ignore[func-returns-value]
                     else:  # EOFToken
                         result = self._handle_eof_in_body(current_token)
                 else:
@@ -379,11 +417,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                         # Tokenizer guarantees non-empty data
                         data = current_token.data
                         if "\x00" in data:
-                            self._parse_error("invalid-codepoint")
                             data = data.replace("\x00", "")
-                        if "\x0c" in data:
-                            self._parse_error("invalid-codepoint")
-                            data = data.replace("\x0c", "")
                         if data:
                             if not is_all_whitespace(data):
                                 self._reconstruct_active_formatting_elements()
@@ -437,10 +471,11 @@ class TreeBuilder(TreeBuilderModesMixin):
             current_token = token_override
             # Continue loop to reprocess
 
-    def finish(self):
+    def finish(self) -> SimpleDomNode:
         if self.fragment_context is not None:
             # For fragments, remove the html wrapper and promote its children
             # Note: html element is always created in fragment setup, so children[0] is always "html"
+            assert self.document.children is not None
             root = self.document.children[0]
             context_elem = self.fragment_context_element
             if context_elem is not None and context_elem.parent is root:
@@ -460,20 +495,28 @@ class TreeBuilder(TreeBuilderModesMixin):
 
     # Insertion mode dispatch ------------------------------------------------
 
-    def _append_comment_to_document(self, text):
+    def _append_comment_to_document(self, text: str) -> None:
         node = SimpleDomNode("#comment", data=text)
+        if self.tokenizer is not None and self.tokenizer.track_node_locations:
+            node._origin_pos = self.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)
         self.document.append_child(node)
 
-    def _append_comment(self, text, parent=None):
+    def _append_comment(self, text: str, parent: Any | None = None) -> None:
         if parent is None:
             parent = self._current_node_or_html()
         # If parent is a template, insert into its content fragment
         if type(parent) is TemplateNode and parent.template_content:
             parent = parent.template_content
         node = SimpleDomNode("#comment", data=text)
+        if self.tokenizer is not None and self.tokenizer.track_node_locations:
+            node._origin_pos = self.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)
         parent.append_child(node)
 
-    def _append_text(self, text):
+    def _append_text(self, text: str) -> None:
         if self.ignore_lf:
             self.ignore_lf = False
             if text.startswith("\n"):
@@ -481,6 +524,9 @@ class TreeBuilder(TreeBuilderModesMixin):
                 if not text:
                     return
 
+        if "\f" in text:
+            text = text.replace("\f", " ")
+
         # Guard against empty stack
         if not self.open_elements:  # pragma: no cover
             return
@@ -493,10 +539,14 @@ class TreeBuilder(TreeBuilderModesMixin):
             if children:
                 last_child = children[-1]
                 if type(last_child) is TextNode:
-                    last_child.data += text
+                    last_child.data = (last_child.data or "") + text
                     return
 
             node = TextNode(text)
+            if self.tokenizer is not None and self.tokenizer.track_node_locations:
+                node._origin_pos = self.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)
             children.append(node)
             node.parent = target
             return
@@ -517,32 +567,45 @@ class TreeBuilder(TreeBuilderModesMixin):
             return
 
         node = TextNode(text)
+        if self.tokenizer is not None and self.tokenizer.track_node_locations:
+            node._origin_pos = self.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)
         reference_node = parent.children[position] if position < len(parent.children) else None
         parent.insert_before(node, reference_node)
 
-    def _current_node_or_html(self):
+    def _current_node_or_html(self) -> Any:
         if self.open_elements:
             return self.open_elements[-1]
         # Stack empty - find html element in document children
         # (may not be first if there are comments/doctype before it)
-        for child in self.document.children:
-            if child.name == "html":
-                return child
-        # Edge case: no html found, return first child or None
-        return self.document.children[0] if self.document.children else None  # pragma: no cover
+        children = self.document.children
+        if children is not None:
+            for child in children:
+                if child.name == "html":
+                    return child
+            # Edge case: no html found, return first child or None
+            return children[0] if children else None  # pragma: no cover
+        return None  # pragma: no cover
 
-    def _create_root(self, attrs):
+    def _create_root(self, attrs: dict[str, str | None]) -> Any:
         node = SimpleDomNode("html", attrs=attrs, namespace="html")
         self.document.append_child(node)
         self.open_elements.append(node)
         return node
 
-    def _insert_element(self, tag, *, push, namespace="html"):
+    def _insert_element(self, tag: Any, *, push: bool, namespace: str = "html") -> Any:
+        node: ElementNode | TemplateNode
         if tag.name == "template" and namespace == "html":
             node = TemplateNode(tag.name, attrs=tag.attrs, namespace=namespace)
         else:
             node = ElementNode(tag.name, attrs=tag.attrs, namespace=namespace)
 
+        if self.tokenizer is not None and self.tokenizer.track_node_locations:
+            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)
+
         # Fast path for common case: not inserting from table
         if not self.insert_from_table:
             target = self._current_node_or_html()
@@ -553,7 +616,8 @@ class TreeBuilder(TreeBuilderModesMixin):
             else:
                 parent = target
 
-            parent.append_child(node)
+            if parent is not None:  # pragma: no branch
+                parent.append_child(node)
 
             if push:
                 self.open_elements.append(node)
@@ -567,28 +631,30 @@ class TreeBuilder(TreeBuilderModesMixin):
             self.open_elements.append(node)
         return node
 
-    def _insert_phantom(self, name):
-        tag = Tag(Tag.START, name, {}, False)
+    def _insert_phantom(self, name: str) -> Any:
+        attrs: dict[str, str | None] = {}
+        tag = Tag(Tag.START, name, attrs, False)
         return self._insert_element(tag, push=True)
 
-    def _insert_body_if_missing(self):
+    def _insert_body_if_missing(self) -> None:
         html_node = self._find_last_on_stack("html")
         node = SimpleDomNode("body", namespace="html")
-        html_node.append_child(node)
-        node.parent = html_node
+        if html_node is not None:  # pragma: no branch
+            html_node.append_child(node)
+            node.parent = html_node
         self.open_elements.append(node)
 
-    def _create_element(self, name, namespace, attrs):
+    def _create_element(self, name: str, namespace: str | None, attrs: dict[str, str | None]) -> Any:
         ns = namespace or "html"
         return ElementNode(name, attrs, ns)
 
-    def _pop_current(self):
+    def _pop_current(self) -> Any:
         return self.open_elements.pop()
 
-    def _in_scope(self, name):
+    def _in_scope(self, name: str) -> bool:
         return self._has_element_in_scope(name, DEFAULT_SCOPE_TERMINATORS)
 
-    def _close_element_by_name(self, name):
+    def _close_element_by_name(self, name: str) -> None:
         # Simple element closing - pops from the named element onwards
         # Used for explicit closing (e.g., when button start tag closes existing button)
         # Caller guarantees name is on the stack via _has_in_scope check
@@ -599,7 +665,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                 return
             index -= 1
 
-    def _any_other_end_tag(self, name):
+    def _any_other_end_tag(self, name: str) -> None:
         # Spec: "Any other end tag" in IN_BODY mode
         # Loop through stack backwards (always terminates: html is special)
         index = len(self.open_elements) - 1
@@ -624,7 +690,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             # Continue to next node (previous in stack)
             index -= 1
 
-    def _add_missing_attributes(self, node, attrs):
+    def _add_missing_attributes(self, node: Any, attrs: dict[str, str]) -> None:
         if not attrs:
             return
         existing = node.attrs
@@ -632,19 +698,19 @@ class TreeBuilder(TreeBuilderModesMixin):
             if name not in existing:
                 existing[name] = value
 
-    def _remove_from_open_elements(self, node):
+    def _remove_from_open_elements(self, node: Any) -> bool:
         for index, current in enumerate(self.open_elements):
             if current is node:
                 del self.open_elements[index]
                 return True
         return False
 
-    def _is_special_element(self, node):
+    def _is_special_element(self, node: Any) -> bool:
         if node.namespace not in {None, "html"}:
             return False
         return node.name in SPECIAL_ELEMENTS
 
-    def _find_active_formatting_index(self, name):
+    def _find_active_formatting_index(self, name: str) -> int | None:
         for index in range(len(self.active_formatting) - 1, -1, -1):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
@@ -653,28 +719,28 @@ class TreeBuilder(TreeBuilderModesMixin):
                 return index
         return None
 
-    def _find_active_formatting_index_by_node(self, node):
+    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:
                 return index
         return None
 
-    def _clone_attributes(self, attrs):
+    def _clone_attributes(self, attrs: dict[str, str | None]) -> dict[str, str | None]:
         return attrs.copy() if attrs else {}
 
-    def _attrs_signature(self, attrs):
+    def _attrs_signature(self, attrs: dict[str, str | None]) -> tuple[tuple[str, str], ...]:
         if not attrs:
             return ()
-        items = []
+        items: list[tuple[str, str]] = []
         for name, value in attrs.items():
             items.append((name, value or ""))
         items.sort()
         return tuple(items)
 
-    def _find_active_formatting_duplicate(self, name, attrs):
+    def _find_active_formatting_duplicate(self, name: str, attrs: dict[str, str | None]) -> int | None:
         signature = self._attrs_signature(attrs)
-        matches = []
+        matches: list[int] = []
         for index, entry in enumerate(self.active_formatting):
             if entry is FORMAT_MARKER:
                 matches.clear()
@@ -686,7 +752,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             return matches[0]
         return None
 
-    def _has_active_formatting_entry(self, name):
+    def _has_active_formatting_entry(self, name: str) -> bool:
         for index in range(len(self.active_formatting) - 1, -1, -1):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
@@ -695,7 +761,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                 return True
         return False
 
-    def _remove_last_active_formatting_by_name(self, name):
+    def _remove_last_active_formatting_by_name(self, name: str) -> None:
         for index in range(len(self.active_formatting) - 1, -1, -1):
             entry = self.active_formatting[index]
             if entry is FORMAT_MARKER:
@@ -704,13 +770,13 @@ class TreeBuilder(TreeBuilderModesMixin):
                 del self.active_formatting[index]
                 return
 
-    def _remove_last_open_element_by_name(self, name):
+    def _remove_last_open_element_by_name(self, name: str) -> None:
         for index in range(len(self.open_elements) - 1, -1, -1):
             if self.open_elements[index].name == name:
                 del self.open_elements[index]
                 return
 
-    def _append_active_formatting_entry(self, name, attrs, node):
+    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(
@@ -722,20 +788,20 @@ class TreeBuilder(TreeBuilderModesMixin):
             },
         )
 
-    def _clear_active_formatting_up_to_marker(self):
+    def _clear_active_formatting_up_to_marker(self) -> None:
         while self.active_formatting:
             entry = self.active_formatting.pop()
             if entry is FORMAT_MARKER:
                 break
 
-    def _push_formatting_marker(self):
+    def _push_formatting_marker(self) -> None:
         self.active_formatting.append(FORMAT_MARKER)
 
-    def _remove_formatting_entry(self, index):
+    def _remove_formatting_entry(self, index: int) -> None:
         assert 0 <= index < len(self.active_formatting), f"Invalid index: {index}"
         del self.active_formatting[index]
 
-    def _reconstruct_active_formatting_elements(self):
+    def _reconstruct_active_formatting_elements(self) -> None:
         if not self.active_formatting:
             return
         last_entry = self.active_formatting[-1]
@@ -757,22 +823,26 @@ class TreeBuilder(TreeBuilderModesMixin):
             entry = self.active_formatting[index]
             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
             index += 1
 
-    def _insert_node_at(self, parent, index, node):
+    def _insert_node_at(self, parent: Any, index: int, node: Any) -> None:
         reference_node = None
         if index is not None and index < len(parent.children):
             reference_node = parent.children[index]
         parent.insert_before(node, reference_node)
 
-    def _find_last_on_stack(self, name):
+    def _find_last_on_stack(self, name: str) -> Any | None:
         for node in reversed(self.open_elements):
             if node.name == name:
                 return node
         return None
 
-    def _clear_stack_until(self, names):
+    def _clear_stack_until(self, names: set[str]) -> None:
         # All callers include "html" in names, so this always terminates via break
         while self.open_elements:
             node = self.open_elements[-1]
@@ -780,7 +850,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                 break
             self.open_elements.pop()
 
-    def _generate_implied_end_tags(self, exclude=None):
+    def _generate_implied_end_tags(self, exclude: str | None = None) -> None:
         # Always terminates: html is not in IMPLIED_END_TAGS
         while self.open_elements:  # pragma: no branch
             node = self.open_elements[-1]
@@ -789,10 +859,10 @@ class TreeBuilder(TreeBuilderModesMixin):
                 continue
             break
 
-    def _has_in_table_scope(self, name):
+    def _has_in_table_scope(self, name: str) -> bool:
         return self._has_element_in_scope(name, TABLE_SCOPE_TERMINATORS, check_integration_points=False)
 
-    def _close_table_cell(self):
+    def _close_table_cell(self) -> bool:
         if self._has_in_table_scope("td"):
             self._end_table_cell("td")
             return True
@@ -801,7 +871,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             return True
         return False
 
-    def _end_table_cell(self, name):
+    def _end_table_cell(self, name: str) -> None:
         self._generate_implied_end_tags(name)
         while self.open_elements:
             node = self.open_elements.pop()
@@ -810,15 +880,22 @@ class TreeBuilder(TreeBuilderModesMixin):
         self._clear_active_formatting_up_to_marker()
         self.mode = InsertionMode.IN_ROW
 
-    def _flush_pending_table_text(self):
+    def _flush_pending_table_text(self) -> None:
         data = "".join(self.pending_table_text)
         self.pending_table_text.clear()
-        if not data:
+        if not data:  # pragma: no cover
             return
         if is_all_whitespace(data):
             self._append_text(data)
             return
-        self._parse_error("foster-parenting-character")
+
+        if self.pending_table_text_should_error:
+            # html5lib reports one foster-parenting error per non-whitespace character.
+            for ch in data:
+                if ch not in " \t\n\r\f":
+                    self._parse_error("foster-parenting-character")
+        self.pending_table_text_should_error = False
+
         previous = self.insert_from_table
         self.insert_from_table = True
         try:
@@ -827,7 +904,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         finally:
             self.insert_from_table = previous
 
-    def _close_table_element(self):
+    def _close_table_element(self) -> bool:
         if not self._has_in_table_scope("table"):
             self._parse_error("unexpected-end-tag", tag_name="table")
             return False
@@ -840,7 +917,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         self._reset_insertion_mode()
         return True
 
-    def _reset_insertion_mode(self):
+    def _reset_insertion_mode(self) -> None:
         # Walk stack backwards - html element always terminates
         idx = len(self.open_elements) - 1
         while idx >= 0:
@@ -880,7 +957,7 @@ class TreeBuilder(TreeBuilderModesMixin):
         # Empty stack fallback
         self.mode = InsertionMode.IN_BODY
 
-    def _should_foster_parenting(self, target, *, for_tag=None, is_text=False):
+    def _should_foster_parenting(self, target: Any, *, for_tag: str | None = None, is_text: bool = False) -> bool:
         if not self.insert_from_table:
             return False
         if target.name not in TABLE_FOSTER_TARGETS:
@@ -891,17 +968,17 @@ class TreeBuilder(TreeBuilderModesMixin):
             return False
         return True
 
-    def _lower_ascii(self, value):
+    def _lower_ascii(self, value: str) -> str:
         return value.lower() if value else ""
 
-    def _adjust_svg_tag_name(self, name):
+    def _adjust_svg_tag_name(self, name: str) -> str:
         lowered = self._lower_ascii(name)
         return SVG_TAG_NAME_ADJUSTMENTS.get(lowered, name)
 
-    def _prepare_foreign_attributes(self, namespace, attrs):
+    def _prepare_foreign_attributes(self, namespace: str, attrs: dict[str, str | None]) -> dict[str, str | None]:
         if not attrs:
             return {}
-        adjusted = {}
+        adjusted: dict[str, str | None] = {}
         for name, value in attrs.items():
             lower_name = self._lower_ascii(name)
             if namespace == "math" and lower_name in MATHML_ATTRIBUTE_ADJUSTMENTS:
@@ -920,14 +997,14 @@ class TreeBuilder(TreeBuilderModesMixin):
             adjusted[name] = value
         return adjusted
 
-    def _node_attribute_value(self, node, name):
+    def _node_attribute_value(self, node: Any, name: str) -> str | None:
         target = self._lower_ascii(name)
         for attr_name, attr_value in node.attrs.items():
             if self._lower_ascii(attr_name) == target:
                 return attr_value or ""
         return None
 
-    def _is_html_integration_point(self, node):
+    def _is_html_integration_point(self, node: Any) -> bool:
         # annotation-xml is an HTML integration point only with specific encoding values
         if node.namespace == "math" and node.name == "annotation-xml":
             encoding = self._node_attribute_value(node, "encoding")
@@ -939,15 +1016,15 @@ class TreeBuilder(TreeBuilderModesMixin):
         # SVG foreignObject, desc, and title are always HTML integration points
         return (node.namespace, node.name) in HTML_INTEGRATION_POINT_SET
 
-    def _is_mathml_text_integration_point(self, node):
+    def _is_mathml_text_integration_point(self, node: Any) -> bool:
         if node.namespace != "math":
             return False
         return (node.namespace, node.name) in MATHML_TEXT_INTEGRATION_POINT_SET
 
-    def _adjusted_current_node(self):
+    def _adjusted_current_node(self) -> Any:
         return self.open_elements[-1]
 
-    def _should_use_foreign_content(self, token):
+    def _should_use_foreign_content(self, token: AnyToken) -> bool:
         current = self._adjusted_current_node()
         # HTML namespace elements don't use foreign content rules
         # (unreachable in practice as foreign content mode only entered for foreign elements)
@@ -978,13 +1055,13 @@ class TreeBuilder(TreeBuilderModesMixin):
 
         return True
 
-    def _foreign_breakout_font(self, tag):
+    def _foreign_breakout_font(self, tag: Any) -> bool:
         for name in tag.attrs.keys():
             if self._lower_ascii(name) in {"color", "face", "size"}:
                 return True
         return False
 
-    def _pop_until_html_or_integration_point(self):
+    def _pop_until_html_or_integration_point(self) -> None:
         # Always terminates: html element has html namespace
         while self.open_elements:  # pragma: no branch
             node = self.open_elements[-1]
@@ -996,7 +1073,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                 return
             self.open_elements.pop()
 
-    def _process_foreign_content(self, token):
+    def _process_foreign_content(self, token: AnyToken) -> Any | None:
         current = self._adjusted_current_node()
 
         if isinstance(token, CharacterTokens):
@@ -1076,7 +1153,7 @@ class TreeBuilder(TreeBuilderModesMixin):
 
             # Per HTML5 spec: if first node doesn't match, it's a parse error
             if first:
-                self._parse_error("unexpected-end-tag-in-foreign-content", tag_name=token.name)
+                self._parse_error("unexpected-end-tag", tag_name=token.name)
                 first = False
 
             # If we hit an HTML element that doesn't match, process in secondary mode
@@ -1087,7 +1164,9 @@ class TreeBuilder(TreeBuilderModesMixin):
         # Stack exhausted without finding match - ignore tag (defensive, html always terminates)
         return None  # pragma: no cover
 
-    def _appropriate_insertion_location(self, override_target=None, *, foster_parenting=False):
+    def _appropriate_insertion_location(
+        self, override_target: Any | None = None, *, foster_parenting: bool = False
+    ) -> tuple[Any, int]:
         if override_target is not None:
             target = override_target
         else:
@@ -1106,24 +1185,28 @@ class TreeBuilder(TreeBuilderModesMixin):
             parent = last_table.parent
             # Table has no parent (e.g., detached) - fall back to target
             if parent is None:  # pragma: no cover
-                return target, len(target.children)
+                children = target.children
+                return target, len(children) if children is not None else 0
+            assert parent.children is not None
             position = parent.children.index(last_table)
             return parent, position
 
         # If target is a template element, insert into its content document fragment
         if type(target) is TemplateNode and target.template_content:
-            return target.template_content, len(target.template_content.children)
+            children = target.template_content.children
+            return target.template_content, len(children) if children is not None else 0
 
-        return target, len(target.children)
+        target_children = target.children
+        return target, len(target_children) if target_children is not None else 0
 
-    def _populate_selectedcontent(self, root):
+    def _populate_selectedcontent(self, root: Any) -> None:
         """Populate selectedcontent elements with content from selected option.
 
         Per HTML5 spec: selectedcontent mirrors the content of the selected option,
         or the first option if none is selected.
         """
         # Find all select elements
-        selects = []
+        selects: list[Any] = []
         self._find_elements(root, "select", selects)
 
         for select in selects:
@@ -1133,7 +1216,7 @@ class TreeBuilder(TreeBuilderModesMixin):
                 continue
 
             # Find all option elements
-            options = []
+            options: list[Any] = []
             self._find_elements(select, "option", options)
 
             # Find selected option or use first one
@@ -1153,7 +1236,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             # Clone content from selected option to selectedcontent
             self._clone_children(selected_option, selectedcontent)
 
-    def _find_elements(self, node, name, result):
+    def _find_elements(self, node: Any, name: str, result: list[Any]) -> None:
         """Recursively find all elements with given name."""
         if node.name == name:
             result.append(node)
@@ -1162,7 +1245,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             for child in node.children:
                 self._find_elements(child, name, result)
 
-    def _find_element(self, node, name):
+    def _find_element(self, node: Any, name: str) -> Any | None:
         """Find first element with given name."""
         if node.name == name:
             return node
@@ -1174,21 +1257,21 @@ class TreeBuilder(TreeBuilderModesMixin):
                     return result
         return None
 
-    def _clone_children(self, source, target):
+    def _clone_children(self, source: Any, target: Any) -> None:
         """Deep clone all children from source to target."""
         for child in source.children:
             target.append_child(child.clone_node(deep=True))
 
-    def _has_in_scope(self, name):
+    def _has_in_scope(self, name: str) -> bool:
         return self._has_element_in_scope(name, DEFAULT_SCOPE_TERMINATORS)
 
-    def _has_in_list_item_scope(self, name):
+    def _has_in_list_item_scope(self, name: str) -> bool:
         return self._has_element_in_scope(name, LIST_ITEM_SCOPE_TERMINATORS)
 
-    def _has_in_definition_scope(self, name):
+    def _has_in_definition_scope(self, name: str) -> bool:
         return self._has_element_in_scope(name, DEFINITION_SCOPE_TERMINATORS)
 
-    def _has_any_in_scope(self, names):
+    def _has_any_in_scope(self, names: set[str]) -> bool:
         # Always terminates: html is in DEFAULT_SCOPE_TERMINATORS
         terminators = DEFAULT_SCOPE_TERMINATORS
         idx = len(self.open_elements) - 1
@@ -1201,7 +1284,7 @@ class TreeBuilder(TreeBuilderModesMixin):
             idx -= 1
         return False  # pragma: no cover - html always terminates
 
-    def process_characters(self, data):
+    def process_characters(self, data: str) -> Any:
         """Optimized path for character tokens."""
         # Check for foreign content first
         current_node = self.open_elements[-1] if self.open_elements else None
@@ -1211,19 +1294,21 @@ class TreeBuilder(TreeBuilderModesMixin):
             return self.process_token(CharacterTokens(data))
 
         if self.mode == InsertionMode.IN_BODY:
-            if "\x00" in data:
-                self._parse_error("invalid-codepoint")
-                data = data.replace("\x00", "")
-
             if not data:
                 return TokenSinkResult.Continue
+            if "\x00" in data:
+                data = data.replace("\x00", "")
+                if not data:
+                    return TokenSinkResult.Continue
 
             if is_all_whitespace(data):
-                self._reconstruct_active_formatting_elements()
+                if self.active_formatting:
+                    self._reconstruct_active_formatting_elements()
                 self._append_text(data)
                 return TokenSinkResult.Continue
 
-            self._reconstruct_active_formatting_elements()
+            if self.active_formatting:
+                self._reconstruct_active_formatting_elements()
             self.frameset_ok = False
             self._append_text(data)
             return TokenSinkResult.Continue