justhtml 0.12.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

justhtml/treebuilder_modes.py

@@ -3,23 +3,30 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from .constants import (
+    FORMAT_MARKER,
     FORMATTING_ELEMENTS,
     HEADING_ELEMENTS,
 )
 from .node import SimpleDomNode, TemplateNode
-from .tokens import CharacterTokens, CommentToken, EOFToken, Tag, TokenSinkResult
+from .tokens import AnyToken, CharacterTokens, CommentToken, DoctypeToken, EOFToken, Tag, TokenSinkResult
 from .treebuilder_utils import (
     InsertionMode,
     doctype_error_and_quirks,
     is_all_whitespace,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    ModeResultTuple = tuple[str, InsertionMode, AnyToken] | tuple[str, InsertionMode, AnyToken, bool]
+    "Result is (instruction, mode, token) or (instruction, mode, token, force_html)"
+
 
 class TreeBuilderModesMixin:
-    def _handle_doctype(self, token: Any) -> Any:
+    def _handle_doctype(self, token: DoctypeToken) -> Literal[0]:
         if self.mode != InsertionMode.INITIAL:
             self._parse_error("unexpected-doctype")
             return TokenSinkResult.Continue
@@ -37,7 +44,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.BEFORE_HTML
         return TokenSinkResult.Continue
 
-    def _mode_initial(self, token: Any) -> Any:
+    def _mode_initial(self, token: Any) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             if is_all_whitespace(token.data):
                 return None
@@ -54,13 +61,13 @@ class TreeBuilderModesMixin:
             return ("reprocess", InsertionMode.BEFORE_HTML, token)
         # Only Tags remain - no DOCTYPE seen, so quirks mode
         if token.kind == Tag.START:
-            self._parse_error("expected-doctype-but-got-start-tag", tag_name=token.name, token=token)
+            self._parse_error("expected-doctype-but-got-start-tag", tag_name=token.name)
         else:
-            self._parse_error("expected-doctype-but-got-end-tag", tag_name=token.name, token=token)
+            self._parse_error("expected-doctype-but-got-end-tag", tag_name=token.name)
         self._set_quirks_mode("quirks")
         return ("reprocess", InsertionMode.BEFORE_HTML, token)
 
-    def _mode_before_html(self, token: Any) -> Any:
+    def _mode_before_html(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens) and is_all_whitespace(token.data):
             return None
         if isinstance(token, CommentToken):
@@ -93,7 +100,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.BEFORE_HEAD
         return ("reprocess", InsertionMode.BEFORE_HEAD, token)
 
-    def _mode_before_head(self, token: Any) -> Any:
+    def _mode_before_head(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             data = token.data or ""
             if "\x00" in data:
@@ -136,7 +143,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_HEAD
         return ("reprocess", InsertionMode.IN_HEAD, token)
 
-    def _mode_in_head(self, token: Any) -> Any:
+    def _mode_in_head(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             if is_all_whitespace(token.data):
                 self._append_text(token.data)
@@ -212,7 +219,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.AFTER_HEAD
         return ("reprocess", InsertionMode.AFTER_HEAD, token)
 
-    def _mode_in_head_noscript(self, token: Any) -> Any:
+    def _mode_in_head_noscript(self, token: AnyToken) -> ModeResultTuple | None:
         """Handle tokens in 'in head noscript' insertion mode (scripting disabled)."""
         if isinstance(token, CharacterTokens):
             data = token.data or ""
@@ -261,15 +268,11 @@ class TreeBuilderModesMixin:
         # All token types are handled above - CharacterTokens, CommentToken, Tag, EOFToken
         return None  # pragma: no cover
 
-    def _mode_after_head(self, token: Any) -> Any:
+    def _mode_after_head(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             data = token.data or ""
             if "\x00" in data:
-                self._parse_error("invalid-codepoint-in-body")
                 data = data.replace("\x00", "")
-            if "\x0c" in data:
-                self._parse_error("invalid-codepoint-in-body")
-                data = data.replace("\x0c", "")
             if not data or is_all_whitespace(data):
                 if data:
                     self._append_text(data)
@@ -331,6 +334,10 @@ 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.name == "template" for node in self.open_elements)
+                if not has_template:
+                    self._parse_error("unexpected-end-tag", tag_name=token.name)
+                    return None
                 return self._mode_in_head(token)
             if token.kind == Tag.END and token.name == "body":
                 self._insert_body_if_missing()
@@ -350,7 +357,7 @@ class TreeBuilderModesMixin:
         self._insert_body_if_missing()
         return ("reprocess", InsertionMode.IN_BODY, token)
 
-    def _mode_text(self, token: Any) -> Any:
+    def _mode_text(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             self._append_text(token.data)
             return None
@@ -366,11 +373,11 @@ class TreeBuilderModesMixin:
         self.mode = self.original_mode or InsertionMode.IN_BODY
         return None
 
-    def _mode_in_body(self, token: Any) -> Any:
+    def _mode_in_body(self, token: Any) -> ModeResultTuple | None:
         handler = self._BODY_TOKEN_HANDLERS.get(type(token))
         return handler(self, token) if handler else None
 
-    def _handle_characters_in_body(self, token: Any) -> Any:
+    def _handle_characters_in_body(self, token: CharacterTokens) -> None:
         data = token.data or ""
         if "\x00" in data:
             self._parse_error("invalid-codepoint")
@@ -384,11 +391,11 @@ class TreeBuilderModesMixin:
         self._append_text(data)
         return
 
-    def _handle_comment_in_body(self, token: Any) -> Any:
+    def _handle_comment_in_body(self, token: CommentToken) -> None:
         self._append_comment(token.data)
         return
 
-    def _handle_tag_in_body(self, token: Any) -> Any:
+    def _handle_tag_in_body(self, token: Tag) -> ModeResultTuple | None:
         if token.kind == Tag.START:
             handler = self._BODY_START_HANDLERS.get(token.name)
             if handler:
@@ -412,7 +419,7 @@ class TreeBuilderModesMixin:
         self._any_other_end_tag(token.name)
         return None
 
-    def _handle_eof_in_body(self, token: Any) -> Any:
+    def _handle_eof_in_body(self, token: EOFToken) -> ModeResultTuple | None:
         # If we're in a template, handle EOF in template mode first
         if self.template_modes:
             return self._mode_in_template(token)
@@ -447,17 +454,19 @@ class TreeBuilderModesMixin:
     # Body mode start tag handlers
     # ---------------------
 
-    def _handle_body_start_html(self, token: Any) -> Any:
+    def _handle_body_start_html(self, token: Tag) -> None:
         if self.template_modes:
             self._parse_error("unexpected-start-tag", tag_name=token.name)
             return
+        # Per spec: parse error; merge attributes onto existing <html>.
+        self._parse_error("unexpected-start-tag", tag_name=token.name)
         # In IN_BODY mode, html element is always at open_elements[0]
         if self.open_elements:  # pragma: no branch
             html = self.open_elements[0]
             self._add_missing_attributes(html, token.attrs)
         return
 
-    def _handle_body_start_body(self, token: Any) -> Any:
+    def _handle_body_start_body(self, token: Tag) -> None:
         if self.template_modes:
             self._parse_error("unexpected-start-tag", tag_name=token.name)
             return
@@ -471,19 +480,19 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_head(self, token: Any) -> Any:
+    def _handle_body_start_head(self, token: Tag) -> None:
         self._parse_error("unexpected-start-tag", tag_name=token.name)
         return
 
-    def _handle_body_start_in_head(self, token: Any) -> Any:
+    def _handle_body_start_in_head(self, token: Tag) -> ModeResultTuple | None:
         return self._mode_in_head(token)
 
-    def _handle_body_start_block_with_p(self, token: Any) -> Any:
+    def _handle_body_start_block_with_p(self, token: Tag) -> None:
         self._close_p_element()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_heading(self, token: Any) -> Any:
+    def _handle_body_start_heading(self, token: Tag) -> None:
         self._close_p_element()
         if self.open_elements and self.open_elements[-1].name in HEADING_ELEMENTS:
             self._parse_error("unexpected-start-tag", tag_name=token.name)
@@ -492,14 +501,14 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_pre_listing(self, token: Any) -> Any:
+    def _handle_body_start_pre_listing(self, token: Tag) -> None:
         self._close_p_element()
         self._insert_element(token, push=True)
         self.ignore_lf = True
         self.frameset_ok = False
         return
 
-    def _handle_body_start_form(self, token: Any) -> Any:
+    def _handle_body_start_form(self, token: Tag) -> None:
         if self.form_element is not None:
             self._parse_error("unexpected-start-tag", tag_name=token.name)
             return
@@ -509,7 +518,7 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_button(self, token: Any) -> Any:
+    def _handle_body_start_button(self, token: Tag) -> None:
         if self._has_in_scope("button"):
             self._parse_error("unexpected-start-tag-implies-end-tag", tag_name=token.name)
             self._close_element_by_name("button")
@@ -517,19 +526,19 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_paragraph(self, token: Any) -> Any:
+    def _handle_body_start_paragraph(self, token: Tag) -> None:
         self._close_p_element()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_math(self, token: Any) -> Any:
+    def _handle_body_start_math(self, token: Tag) -> None:
         self._reconstruct_active_formatting_elements()
         attrs = self._prepare_foreign_attributes("math", token.attrs)
         new_tag = Tag(Tag.START, token.name, attrs, token.self_closing)
         self._insert_element(new_tag, push=not token.self_closing, namespace="math")
         return
 
-    def _handle_body_start_svg(self, token: Any) -> Any:
+    def _handle_body_start_svg(self, token: Tag) -> None:
         self._reconstruct_active_formatting_elements()
         adjusted_name = self._adjust_svg_tag_name(token.name)
         attrs = self._prepare_foreign_attributes("svg", token.attrs)
@@ -537,7 +546,7 @@ class TreeBuilderModesMixin:
         self._insert_element(new_tag, push=not token.self_closing, namespace="svg")
         return
 
-    def _handle_body_start_li(self, token: Any) -> Any:
+    def _handle_body_start_li(self, token: Tag) -> None:
         self.frameset_ok = False
         self._close_p_element()
         if self._has_in_list_item_scope("li"):
@@ -545,7 +554,7 @@ class TreeBuilderModesMixin:
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_dd_dt(self, token: Any) -> Any:
+    def _handle_body_start_dd_dt(self, token: Tag) -> None:
         self.frameset_ok = False
         self._close_p_element()
         name = token.name
@@ -574,6 +583,10 @@ class TreeBuilderModesMixin:
             # 3. Find formatting element
             formatting_element_index = self._find_active_formatting_index(subject)
             if formatting_element_index is None:
+                # html5lib reports a parse error when an end tag for a formatting
+                # element triggers the adoption agency algorithm but no matching
+                # active formatting entry exists.
+                self._parse_error("adoption-agency-1.3")
                 return
 
             formatting_element_entry = self.active_formatting[formatting_element_index]
@@ -607,7 +620,7 @@ class TreeBuilderModesMixin:
             if furthest_block is None:
                 # formatting_element is known to be on the stack
                 while True:
-                    popped = self.open_elements.pop()
+                    popped = self._pop_current()
                     if popped is formatting_element:
                         break
                 self._remove_formatting_entry(formatting_element_index)
@@ -651,6 +664,10 @@ class TreeBuilderModesMixin:
                 # 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.open_elements[self.open_elements.index(node)] = new_element
                 node = new_element
@@ -684,6 +701,10 @@ 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
 
             # 13. Move children of furthest block
@@ -706,8 +727,9 @@ class TreeBuilderModesMixin:
             furthest_block_index = self.open_elements.index(furthest_block)
             self.open_elements.insert(furthest_block_index + 1, new_formatting_element)
 
-    def _handle_body_start_a(self, token: Any) -> Any:
+    def _handle_body_start_a(self, token: Tag) -> None:
         if self._has_active_formatting_entry("a"):
+            self._parse_error("unexpected-start-tag-implies-end-tag", tag_name=token.name)
             self._adoption_agency("a")
             self._remove_last_active_formatting_by_name("a")
             self._remove_last_open_element_by_name("a")
@@ -716,7 +738,7 @@ class TreeBuilderModesMixin:
         self._append_active_formatting_entry("a", token.attrs, node)
         return
 
-    def _handle_body_start_formatting(self, token: Any) -> Any:
+    def _handle_body_start_formatting(self, token: Tag) -> None:
         name = token.name
         if name == "nobr" and self._in_scope("nobr"):
             self._adoption_agency("nobr")
@@ -730,21 +752,21 @@ class TreeBuilderModesMixin:
         self._append_active_formatting_entry(name, token.attrs, node)
         return
 
-    def _handle_body_start_applet_like(self, token: Any) -> Any:
+    def _handle_body_start_applet_like(self, token: Tag) -> None:
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         self._push_formatting_marker()
         self.frameset_ok = False
         return
 
-    def _handle_body_start_br(self, token: Any) -> Any:
+    def _handle_body_start_br(self, token: Tag) -> None:
         self._close_p_element()
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=False)
         self.frameset_ok = False
         return
 
-    def _handle_body_start_frameset(self, token: Any) -> Any:
+    def _handle_body_start_frameset(self, token: Tag) -> None:
         if not self.frameset_ok:
             self._parse_error("unexpected-start-tag-ignored", tag_name=token.name)
             return
@@ -769,17 +791,17 @@ class TreeBuilderModesMixin:
     # Body mode end tag handlers
     # ---------------------
 
-    def _handle_body_end_body(self, token: Any) -> Any:
+    def _handle_body_end_body(self, token: Tag) -> None:
         if self._in_scope("body"):
             self.mode = InsertionMode.AFTER_BODY
         return
 
-    def _handle_body_end_html(self, token: Any) -> Any:
+    def _handle_body_end_html(self, token: Tag) -> ModeResultTuple | None:
         if self._in_scope("body"):
             return ("reprocess", InsertionMode.AFTER_BODY, token)
         return None
 
-    def _handle_body_end_p(self, token: Any) -> Any:
+    def _handle_body_end_p(self, token: Tag) -> None:
         if not self._close_p_element():
             self._parse_error("unexpected-end-tag", tag_name=token.name)
             phantom = Tag(Tag.START, "p", {}, False)
@@ -787,21 +809,21 @@ class TreeBuilderModesMixin:
             self._close_p_element()
         return
 
-    def _handle_body_end_li(self, token: Any) -> Any:
+    def _handle_body_end_li(self, token: Tag) -> None:
         if not self._has_in_list_item_scope("li"):
             self._parse_error("unexpected-end-tag", tag_name=token.name)
             return
         self._pop_until_any_inclusive({"li"})
         return
 
-    def _handle_body_end_dd_dt(self, token: Any) -> Any:
+    def _handle_body_end_dd_dt(self, token: Tag) -> None:
         name = token.name
         if not self._has_in_definition_scope(name):
             self._parse_error("unexpected-end-tag", tag_name=name)
             return
         self._pop_until_any_inclusive({"dd", "dt"})
 
-    def _handle_body_end_form(self, token: Any) -> Any:
+    def _handle_body_end_form(self, token: Tag) -> None:
         if self.form_element is None:
             self._parse_error("unexpected-end-tag", tag_name=token.name)
             return
@@ -811,20 +833,20 @@ class TreeBuilderModesMixin:
             self._parse_error("unexpected-end-tag", tag_name=token.name)
         return
 
-    def _handle_body_end_applet_like(self, token: Any) -> Any:
+    def _handle_body_end_applet_like(self, token: Tag) -> None:
         name = token.name
         if not self._in_scope(name):
             self._parse_error("unexpected-end-tag", tag_name=name)
             return
         # Element verified in scope above
         while self.open_elements:  # pragma: no branch
-            popped = self.open_elements.pop()
+            popped = self._pop_current()
             if popped.name == name:
                 break
         self._clear_active_formatting_up_to_marker()
         return
 
-    def _handle_body_end_heading(self, token: Any) -> Any:
+    def _handle_body_end_heading(self, token: Tag) -> None:
         name = token.name
         if not self._has_any_in_scope(HEADING_ELEMENTS):
             self._parse_error("unexpected-end-tag", tag_name=name)
@@ -834,12 +856,12 @@ class TreeBuilderModesMixin:
             self._parse_error("end-tag-too-early", tag_name=name)
         # Heading verified in scope by caller
         while self.open_elements:  # pragma: no branch
-            popped = self.open_elements.pop()
+            popped = self._pop_current()
             if popped.name in HEADING_ELEMENTS:
                 break
         return
 
-    def _handle_body_end_block(self, token: Any) -> Any:
+    def _handle_body_end_block(self, token: Tag) -> None:
         name = token.name
         if not self._in_scope(name):
             self._parse_error("unexpected-end-tag", tag_name=name)
@@ -850,9 +872,10 @@ class TreeBuilderModesMixin:
         self._pop_until_any_inclusive({name})
         return
 
-    def _handle_body_end_template(self, token: Any) -> Any:
+    def _handle_body_end_template(self, token: Tag) -> None:
         has_template = any(node.name == "template" for node in self.open_elements)
         if not has_template:
+            self._parse_error("unexpected-end-tag", tag_name=token.name)
             return
         self._generate_implied_end_tags()
         self._pop_until_inclusive("template")
@@ -863,18 +886,18 @@ class TreeBuilderModesMixin:
         self._reset_insertion_mode()
         return
 
-    def _handle_body_start_structure_ignored(self, token: Any) -> Any:
+    def _handle_body_start_structure_ignored(self, token: Tag) -> None:
         self._parse_error("unexpected-start-tag-ignored", tag_name=token.name)
         return
 
-    def _handle_body_start_col_or_frame(self, token: Any) -> Any:
+    def _handle_body_start_col_or_frame(self, token: Tag) -> None:
         if self.fragment_context is None:
             self._parse_error("unexpected-start-tag-ignored", tag_name=token.name)
             return
         self._insert_element(token, push=False)
         return
 
-    def _handle_body_start_image(self, token: Any) -> Any:
+    def _handle_body_start_image(self, token: Tag) -> None:
         self._parse_error("image-start-tag", tag_name=token.name)
         img_token = Tag(Tag.START, "img", token.attrs, token.self_closing)
         self._reconstruct_active_formatting_elements()
@@ -882,17 +905,17 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_void_with_formatting(self, token: Any) -> Any:
+    def _handle_body_start_void_with_formatting(self, token: Tag) -> None:
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=False)
         self.frameset_ok = False
         return
 
-    def _handle_body_start_simple_void(self, token: Any) -> Any:
+    def _handle_body_start_simple_void(self, token: Tag) -> None:
         self._insert_element(token, push=False)
         return
 
-    def _handle_body_start_input(self, token: Any) -> Any:
+    def _handle_body_start_input(self, token: Tag) -> None:
         input_type = None
         for name, value in token.attrs.items():
             if name == "type":
@@ -903,7 +926,7 @@ class TreeBuilderModesMixin:
             self.frameset_ok = False
         return
 
-    def _handle_body_start_table(self, token: Any) -> Any:
+    def _handle_body_start_table(self, token: Tag) -> None:
         if self.quirks_mode != "quirks":
             self._close_p_element()
         self._insert_element(token, push=True)
@@ -911,7 +934,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_TABLE
         return
 
-    def _handle_body_start_plaintext_xmp(self, token: Any) -> Any:
+    def _handle_body_start_plaintext_xmp(self, token: Tag) -> None:
         self._close_p_element()
         self._insert_element(token, push=True)
         self.frameset_ok = False
@@ -923,66 +946,88 @@ class TreeBuilderModesMixin:
             self.mode = InsertionMode.TEXT
         return
 
-    def _handle_body_start_textarea(self, token: Any) -> Any:
+    def _handle_body_start_textarea(self, token: Tag) -> None:
         self._insert_element(token, push=True)
         self.ignore_lf = True
         self.frameset_ok = False
         return
 
-    def _handle_body_start_select(self, token: Any) -> Any:
+    def _handle_body_start_select(self, token: Tag) -> None:
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         self.frameset_ok = False
         self._reset_insertion_mode()
         return
 
-    def _handle_body_start_option(self, token: Any) -> Any:
+    def _handle_body_start_option(self, token: Tag) -> None:
         if self.open_elements and self.open_elements[-1].name == "option":
-            self.open_elements.pop()
+            self._pop_current()
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_optgroup(self, token: Any) -> Any:
+    def _handle_body_start_optgroup(self, token: Tag) -> None:
         if self.open_elements and self.open_elements[-1].name == "option":
-            self.open_elements.pop()
+            self._pop_current()
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_rp_rt(self, token: Any) -> Any:
+    def _handle_body_start_rp_rt(self, token: Tag) -> None:
         self._generate_implied_end_tags(exclude="rtc")
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_rb_rtc(self, token: Any) -> Any:
+    def _handle_body_start_rb_rtc(self, token: Tag) -> None:
         if self.open_elements and self.open_elements[-1].name in {"rb", "rp", "rt", "rtc"}:
             self._generate_implied_end_tags()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_table_parse_error(self, token: Any) -> Any:
+    def _handle_body_start_table_parse_error(self, token: Tag) -> None:
         self._parse_error("unexpected-start-tag", tag_name=token.name)
         return
 
-    def _handle_body_start_default(self, token: Any) -> Any:
+    def _handle_body_start_default(self, token: Tag) -> ModeResultTuple | None:
         self._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         if token.self_closing:
             self._parse_error("non-void-html-element-start-tag-with-trailing-solidus", tag_name=token.name)
         # Elements reaching here have no handler - never in FRAMESET_NEUTRAL/FORMATTING_ELEMENTS
         self.frameset_ok = False
-        return
+        return None
 
-    def _mode_in_table(self, token: Any) -> Any:
+    def _mode_in_table(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             data = token.data or ""
             if "\x00" in data:
-                self._parse_error("unexpected-null-character")
                 data = data.replace("\x00", "")
                 if not data:
                     return None
                 token = CharacterTokens(data)
+
+            if is_all_whitespace(data):
+                self._append_text(data)
+                return None
+
+            # html5lib-tests expect that some table foster-parenting text triggered by a
+            # misnested formatting element (<a>) only produces an implied-end-tag error
+            # when the table closes, not an additional character-in-table error.
+            suppress_table_char_error = False
+            if self.active_formatting:
+                for idx in range(len(self.active_formatting) - 1, -1, -1):
+                    entry = self.active_formatting[idx]
+                    if entry is FORMAT_MARKER:
+                        break
+                    if entry["name"] == "a":
+                        if entry["node"] not in self.open_elements:
+                            suppress_table_char_error = True
+                        break
+
+            if not suppress_table_char_error:
+                self.pending_table_text_should_error = True
+            else:
+                self.pending_table_text_should_error = False
             self.pending_table_text = []
             self.table_text_original_mode = self.mode
             self.mode = InsertionMode.IN_TABLE_TEXT
@@ -1046,16 +1091,16 @@ class TreeBuilderModesMixin:
                     if input_type == "hidden":
                         self._parse_error("unexpected-hidden-input-in-table")
                         self._insert_element(token, push=True)
-                        self.open_elements.pop()  # push=True always adds to stack
+                        self._pop_current()  # push=True always adds to stack
                         return None
                 if name == "form":
                     self._parse_error("unexpected-form-in-table")
                     if self.form_element is None:
                         node = self._insert_element(token, push=True)
                         self.form_element = node
-                        self.open_elements.pop()  # push=True always adds to stack
+                        self._pop_current()  # push=True always adds to stack
                     return None
-                self._parse_error("unexpected-start-tag-implies-table-voodoo", tag_name=name)
+                self._parse_error("foster-parenting-start-tag", tag_name=name)
                 previous = self.insert_from_table
                 self.insert_from_table = True
                 try:
@@ -1082,26 +1127,40 @@ class TreeBuilderModesMixin:
         if self.template_modes:
             return self._mode_in_template(token)
         if self._has_in_table_scope("table"):
-            self._parse_error("expected-closing-tag-but-got-eof", tag_name="table")
+            self._parse_error("eof-in-table")
         return None
 
-    def _mode_in_table_text(self, token: Any) -> Any:
+    def _mode_in_table_text(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             # IN_TABLE mode guarantees non-empty data
             data = token.data
-            if "\x0c" in data:
-                self._parse_error("invalid-codepoint-in-table-text")
-                data = data.replace("\x0c", "")
-            if data:
-                self.pending_table_text.append(data)
+            self.pending_table_text.append(data)
             return None
+
+        if (
+            self.pending_table_text
+            and isinstance(token, Tag)
+            and token.kind == Tag.END
+            and token.name == "table"
+            and not is_all_whitespace("".join(self.pending_table_text))
+        ):
+            # If a misnested <a> exists only in the active formatting list, html5lib
+            # reports the implied close when the table ends.
+            if self.active_formatting:
+                for idx in range(len(self.active_formatting) - 1, -1, -1):
+                    entry = self.active_formatting[idx]
+                    if entry is FORMAT_MARKER:
+                        break
+                    if entry["name"] == "a" and entry["node"] not in self.open_elements:
+                        self._parse_error("unexpected-implied-end-tag-in-table-view")
+                        break
         self._flush_pending_table_text()
         original = self.table_text_original_mode or InsertionMode.IN_TABLE
         self.table_text_original_mode = None
         self.mode = original
         return ("reprocess", original, token)
 
-    def _mode_in_caption(self, token: Any) -> Any:
+    def _mode_in_caption(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             return self._mode_in_body(token)
         if isinstance(token, CommentToken):
@@ -1147,14 +1206,14 @@ class TreeBuilderModesMixin:
         self._generate_implied_end_tags()
         # Caption verified in scope above
         while self.open_elements:  # pragma: no branch
-            node = self.open_elements.pop()
+            node = self._pop_current()
             if node.name == "caption":
                 break
         self._clear_active_formatting_up_to_marker()
         self.mode = InsertionMode.IN_TABLE
         return True
 
-    def _mode_in_column_group(self, token: Any) -> Any:
+    def _mode_in_column_group(self, token: AnyToken) -> ModeResultTuple | None:
         current = self.open_elements[-1] if self.open_elements else None
         if isinstance(token, CharacterTokens):
             data = token.data or ""
@@ -1191,7 +1250,7 @@ class TreeBuilderModesMixin:
                     return self._mode_in_body(token)
                 if name == "col":
                     self._insert_element(token, push=True)
-                    self.open_elements.pop()  # push=True always adds to stack
+                    self._pop_current()  # push=True always adds to stack
                     return None
                 if name == "template":
                     # Template is handled by delegating to IN_HEAD
@@ -1249,7 +1308,7 @@ class TreeBuilderModesMixin:
         return None
         # Per spec: EOF when current is html - implicit None return
 
-    def _mode_in_table_body(self, token: Any) -> Any:
+    def _mode_in_table_body(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens) or isinstance(token, CommentToken):
             return self._mode_in_table(token)
         if isinstance(token, Tag):
@@ -1284,7 +1343,7 @@ class TreeBuilderModesMixin:
                         return None
                     # Pop tbody/tfoot/thead (stack always has elements here in normal parsing)
                     if self.open_elements:
-                        self.open_elements.pop()
+                        self._pop_current()
                         self.mode = InsertionMode.IN_TABLE
                         return ("reprocess", InsertionMode.IN_TABLE, token)
                     # Empty stack edge case - go directly to IN_TABLE without reprocess
@@ -1315,7 +1374,7 @@ class TreeBuilderModesMixin:
                     self._parse_error("unexpected-end-tag", tag_name=token.name)
                     return None
                 if current and current.name in {"tbody", "tfoot", "thead"}:
-                    self.open_elements.pop()
+                    self._pop_current()
                 self.mode = InsertionMode.IN_TABLE
                 return ("reprocess", InsertionMode.IN_TABLE, token)
             if name in {"caption", "col", "colgroup", "td", "th", "tr"}:
@@ -1325,7 +1384,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return self._mode_in_table(token)
 
-    def _mode_in_row(self, token: Any) -> Any:
+    def _mode_in_row(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens) or isinstance(token, CommentToken):
             return self._mode_in_table(token)
         if isinstance(token, Tag):
@@ -1378,14 +1437,14 @@ class TreeBuilderModesMixin:
         self._clear_stack_until({"tr", "template", "html"})
         # Pop tr if on top (may not be if stack was exhausted)
         if self.open_elements and self.open_elements[-1].name == "tr":
-            self.open_elements.pop()
+            self._pop_current()
         # When in a template, restore template mode; otherwise use IN_TABLE_BODY
         if self.template_modes:
             self.mode = self.template_modes[-1]
         else:
             self.mode = InsertionMode.IN_TABLE_BODY
 
-    def _mode_in_cell(self, token: Any) -> Any:
+    def _mode_in_cell(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             previous = self.insert_from_table
             self.insert_from_table = False
@@ -1439,15 +1498,11 @@ class TreeBuilderModesMixin:
             return ("reprocess", self.mode, token)
         return self._mode_in_table(token)
 
-    def _mode_in_select(self, token: Any) -> Any:
+    def _mode_in_select(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             data = token.data or ""
             if "\x00" in data:
-                self._parse_error("invalid-codepoint-in-select")
                 data = data.replace("\x00", "")
-            if "\x0c" in data:
-                self._parse_error("invalid-codepoint-in-select")
-                data = data.replace("\x0c", "")
             if data:
                 self._reconstruct_active_formatting_elements()
                 self._append_text(data)
@@ -1462,26 +1517,26 @@ class TreeBuilderModesMixin:
                     return ("reprocess", InsertionMode.IN_BODY, token)
                 if name == "option":
                     if self.open_elements and self.open_elements[-1].name == "option":
-                        self.open_elements.pop()
+                        self._pop_current()
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=True)
                     return None
                 if name == "optgroup":
                     if self.open_elements and self.open_elements[-1].name == "option":
-                        self.open_elements.pop()
+                        self._pop_current()
                     if self.open_elements and self.open_elements[-1].name == "optgroup":
-                        self.open_elements.pop()
+                        self._pop_current()
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=True)
                     return None
                 if name == "select":
-                    self._parse_error("unexpected-start-tag-implies-end-tag", tag_name=name)
+                    self._parse_error("unexpected-select-in-select")
                     # select is always in scope in IN_SELECT mode
                     self._pop_until_any_inclusive({"select"})
                     self._reset_insertion_mode()
                     return None
                 if name in {"input", "textarea"}:
-                    self._parse_error("unexpected-start-tag-implies-end-tag", tag_name=name)
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     # select is always in scope in IN_SELECT mode
                     self._pop_until_any_inclusive({"select"})
                     self._reset_insertion_mode()
@@ -1491,7 +1546,7 @@ class TreeBuilderModesMixin:
                     self._insert_element(token, push=False)
                     return None
                 if name in {"caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr", "table"}:
-                    self._parse_error("unexpected-start-tag-implies-end-tag", tag_name=name)
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     # select is always in scope in IN_SELECT mode
                     self._pop_until_any_inclusive({"select"})
                     self._reset_insertion_mode()
@@ -1509,45 +1564,53 @@ class TreeBuilderModesMixin:
                     self._append_active_formatting_entry(name, token.attrs, node)
                     return None
                 if name == "hr":
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     # Per spec: pop option and optgroup before inserting hr (makes hr sibling, not child)
                     if self.open_elements and self.open_elements[-1].name == "option":
-                        self.open_elements.pop()
+                        self._pop_current()
                     if self.open_elements and self.open_elements[-1].name == "optgroup":
-                        self.open_elements.pop()
+                        self._pop_current()
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=False)
                     return None
                 if name == "menuitem":
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=True)
                     return None
                 # Allow common HTML elements in select (newer spec)
                 if name in {"p", "div", "span", "button", "datalist", "selectedcontent"}:
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=not token.self_closing)
                     return None
                 if name in {"br", "img"}:
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=False)
                     return None
                 if name == "plaintext":
                     # Per spec: plaintext element is inserted in select (consumes all remaining text)
+                    self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                     self._reconstruct_active_formatting_elements()
                     self._insert_element(token, push=True)
+                    return None
+                # Any other start tag: parse error, ignore.
+                self._parse_error("unexpected-start-tag-in-select", tag_name=name)
                 return None
             if name == "optgroup":
                 if self.open_elements and self.open_elements[-1].name == "option":
-                    self.open_elements.pop()
+                    self._pop_current()
                 if self.open_elements and self.open_elements[-1].name == "optgroup":
-                    self.open_elements.pop()
+                    self._pop_current()
                 else:
-                    self._parse_error("unexpected-end-tag", tag_name=token.name)
+                    self._parse_error("unexpected-end-tag-in-select", tag_name=token.name)
                 return None
             if name == "option":
                 if self.open_elements and self.open_elements[-1].name == "option":
-                    self.open_elements.pop()
+                    self._pop_current()
                 else:
-                    self._parse_error("unexpected-end-tag", tag_name=token.name)
+                    self._parse_error("unexpected-end-tag-in-select", tag_name=token.name)
                 return None
             if name == "select":
                 # In IN_SELECT mode, select is always in scope - pop to it
@@ -1559,17 +1622,20 @@ class TreeBuilderModesMixin:
                 # select is always on stack in IN_SELECT mode
                 select_node = self._find_last_on_stack("select")
                 fmt_index = self._find_active_formatting_index(name)
-                if fmt_index is not None:
-                    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)
-                        if target_index < select_index:
-                            self._parse_error("unexpected-end-tag", tag_name=name)
-                            return None
+                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"]
+                if target in self.open_elements:  # pragma: no branch
+                    select_index = self.open_elements.index(select_node)
+                    target_index = self.open_elements.index(target)
+                    if target_index < select_index:
+                        self._parse_error("unexpected-end-tag-in-select", tag_name=name)
+                        return None
                 self._adoption_agency(name)
                 return None
             if name in {"p", "div", "span", "button", "datalist", "selectedcontent"}:
+                self._parse_error("unexpected-end-tag-in-select", tag_name=name)
                 # Per HTML5 spec: these end tags in select mode close the element if it's on the stack.
                 # But we must not pop across the select boundary (i.e., don't pop elements BEFORE select).
                 select_idx = None
@@ -1583,14 +1649,12 @@ class TreeBuilderModesMixin:
                 # i.e., the target is inside the select or there's no select
                 if target_idx is not None and (select_idx is None or target_idx > select_idx):
                     while True:
-                        popped = self.open_elements.pop()
+                        popped = self._pop_current()
                         if popped.name == name:
                             break
-                else:
-                    self._parse_error("unexpected-end-tag", tag_name=name)
                 return None
             if name in {"caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr", "table"}:
-                self._parse_error("unexpected-end-tag", tag_name=name)
+                self._parse_error("unexpected-end-tag-in-select", tag_name=name)
                 # select is always in scope in IN_SELECT mode
                 self._pop_until_any_inclusive({"select"})
                 self._reset_insertion_mode()
@@ -1601,7 +1665,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return self._mode_in_body(token)
 
-    def _mode_in_template(self, token: Any) -> Any:
+    def _mode_in_template(self, token: AnyToken) -> ModeResultTuple | None:
         # § The "in template" insertion mode
         # https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intemplate
         if isinstance(token, CharacterTokens):
@@ -1680,7 +1744,7 @@ class TreeBuilderModesMixin:
             return ("reprocess", self.mode, token)
         return None
 
-    def _mode_after_body(self, token: Any) -> Any:
+    def _mode_after_body(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             if is_all_whitespace(token.data):
                 # Whitespace is processed using InBody rules (appended to body)
@@ -1701,7 +1765,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return None
 
-    def _mode_after_after_body(self, token: Any) -> Any:
+    def _mode_after_after_body(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             if is_all_whitespace(token.data):
                 # Per spec: whitespace characters are inserted using the rules for the "in body" mode
@@ -1728,7 +1792,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return None
 
-    def _mode_in_frameset(self, token: Any) -> Any:
+    def _mode_in_frameset(self, token: AnyToken) -> ModeResultTuple | None:
         # Per HTML5 spec §13.2.6.4.16: In frameset insertion mode
         if isinstance(token, CharacterTokens):
             # Only whitespace characters allowed; ignore all others
@@ -1749,13 +1813,13 @@ class TreeBuilderModesMixin:
                 if self.open_elements and self.open_elements[-1].name == "html":
                     self._parse_error("unexpected-end-tag", tag_name=token.name)
                     return None
-                self.open_elements.pop()
+                self._pop_current()
                 if self.open_elements and self.open_elements[-1].name != "frameset":
                     self.mode = InsertionMode.AFTER_FRAMESET
                 return None
             if token.kind == Tag.START and token.name == "frame":
                 self._insert_element(token, push=True)
-                self.open_elements.pop()
+                self._pop_current()
                 return None
             if token.kind == Tag.START and token.name == "noframes":
                 # Per spec: use IN_HEAD rules but preserve current mode for TEXT restoration
@@ -1770,11 +1834,14 @@ class TreeBuilderModesMixin:
         self._parse_error("unexpected-token-in-frameset")
         return None
 
-    def _mode_after_frameset(self, token: Any) -> Any:
+    def _mode_after_frameset(self, token: AnyToken) -> ModeResultTuple | None:
         # Per HTML5 spec §13.2.6.4.17: After frameset insertion mode
         if isinstance(token, CharacterTokens):
-            # Only whitespace characters allowed; ignore all others
-            whitespace = "".join(ch for ch in token.data if ch in "\t\n\f\r ")
+            # Only whitespace characters allowed; non-whitespace is a parse error.
+            data = token.data or ""
+            whitespace = "".join(ch for ch in data if ch in "\t\n\f\r ")
+            if any(ch not in "\t\n\f\r " for ch in data):
+                self._parse_error("unexpected-token-after-frameset")
             if whitespace:
                 self._append_text(whitespace)
             return None
@@ -1787,6 +1854,9 @@ class TreeBuilderModesMixin:
             if token.kind == Tag.END and token.name == "html":
                 self.mode = InsertionMode.AFTER_AFTER_FRAMESET
                 return None
+            if token.kind == Tag.END and token.name == "frameset":
+                self._parse_error("unexpected-token-after-frameset")
+                return None
             if token.kind == Tag.START and token.name == "noframes":
                 # Insert noframes element directly and switch to TEXT mode
                 self._insert_element(token, push=True)
@@ -1799,7 +1869,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_FRAMESET
         return ("reprocess", InsertionMode.IN_FRAMESET, token)
 
-    def _mode_after_after_frameset(self, token: Any) -> Any:
+    def _mode_after_after_frameset(self, token: AnyToken) -> ModeResultTuple | None:
         # Per HTML5 spec §13.2.6.4.18: After after frameset insertion mode
         if isinstance(token, CharacterTokens):
             # Whitespace is processed using InBody rules
@@ -1830,7 +1900,7 @@ class TreeBuilderModesMixin:
 
     # Helpers ----------------------------------------------------------------
 
-    _MODE_HANDLERS = [
+    _MODE_HANDLERS: list[Callable[[TreeBuilderModesMixin, AnyToken], ModeResultTuple | None]] = [
         _mode_initial,
         _mode_before_html,
         _mode_before_head,
@@ -1855,14 +1925,14 @@ class TreeBuilderModesMixin:
         _mode_in_template,
     ]
 
-    _BODY_TOKEN_HANDLERS = {
+    _BODY_TOKEN_HANDLERS: dict[type[AnyToken], Callable[[TreeBuilderModesMixin, Any], ModeResultTuple | None]] = {
         CharacterTokens: _handle_characters_in_body,
         CommentToken: _handle_comment_in_body,
         Tag: _handle_tag_in_body,
         EOFToken: _handle_eof_in_body,
     }
 
-    _BODY_START_HANDLERS = {
+    _BODY_START_HANDLERS: dict[str, Callable[[TreeBuilderModesMixin, Tag], ModeResultTuple | None]] = {
         "a": _handle_body_start_a,
         "address": _handle_body_start_block_with_p,
         "applet": _handle_body_start_applet_like,
@@ -1967,7 +2037,7 @@ class TreeBuilderModesMixin:
         "wbr": _handle_body_start_void_with_formatting,
         "xmp": _handle_body_start_plaintext_xmp,
     }
-    _BODY_END_HANDLERS = {
+    _BODY_END_HANDLERS: dict[str, Callable[[TreeBuilderModesMixin, Tag], ModeResultTuple | None]] = {
         "address": _handle_body_end_block,
         "applet": _handle_body_end_applet_like,
         "article": _handle_body_end_block,