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

justhtml/treebuilder_modes.py

@@ -1,21 +1,32 @@
 # ruff: noqa: S101, RUF012
+# mypy: disable-error-code="attr-defined, has-type, var-annotated, assignment"
 
+from __future__ import annotations
+
+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):
+    def _handle_doctype(self, token: DoctypeToken) -> Literal[0]:
         if self.mode != InsertionMode.INITIAL:
             self._parse_error("unexpected-doctype")
             return TokenSinkResult.Continue
@@ -33,7 +44,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.BEFORE_HTML
         return TokenSinkResult.Continue
 
-    def _mode_initial(self, token):
+    def _mode_initial(self, token: Any) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             if is_all_whitespace(token.data):
                 return None
@@ -50,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):
+    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):
@@ -89,7 +100,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.BEFORE_HEAD
         return ("reprocess", InsertionMode.BEFORE_HEAD, token)
 
-    def _mode_before_head(self, token):
+    def _mode_before_head(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             data = token.data or ""
             if "\x00" in data:
@@ -132,7 +143,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_HEAD
         return ("reprocess", InsertionMode.IN_HEAD, token)
 
-    def _mode_in_head(self, token):
+    def _mode_in_head(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             if is_all_whitespace(token.data):
                 self._append_text(token.data)
@@ -208,7 +219,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.AFTER_HEAD
         return ("reprocess", InsertionMode.AFTER_HEAD, token)
 
-    def _mode_in_head_noscript(self, token):
+    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 ""
@@ -257,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):
+    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)
@@ -327,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()
@@ -346,7 +357,7 @@ class TreeBuilderModesMixin:
         self._insert_body_if_missing()
         return ("reprocess", InsertionMode.IN_BODY, token)
 
-    def _mode_text(self, token):
+    def _mode_text(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             self._append_text(token.data)
             return None
@@ -362,11 +373,11 @@ class TreeBuilderModesMixin:
         self.mode = self.original_mode or InsertionMode.IN_BODY
         return None
 
-    def _mode_in_body(self, token):
+    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):
+    def _handle_characters_in_body(self, token: CharacterTokens) -> None:
         data = token.data or ""
         if "\x00" in data:
             self._parse_error("invalid-codepoint")
@@ -380,11 +391,11 @@ class TreeBuilderModesMixin:
         self._append_text(data)
         return
 
-    def _handle_comment_in_body(self, token):
+    def _handle_comment_in_body(self, token: CommentToken) -> None:
         self._append_comment(token.data)
         return
 
-    def _handle_tag_in_body(self, token):
+    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:
@@ -408,7 +419,7 @@ class TreeBuilderModesMixin:
         self._any_other_end_tag(token.name)
         return None
 
-    def _handle_eof_in_body(self, token):
+    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)
@@ -443,17 +454,19 @@ class TreeBuilderModesMixin:
     # Body mode start tag handlers
     # ---------------------
 
-    def _handle_body_start_html(self, token):
+    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):
+    def _handle_body_start_body(self, token: Tag) -> None:
         if self.template_modes:
             self._parse_error("unexpected-start-tag", tag_name=token.name)
             return
@@ -467,19 +480,19 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_head(self, token):
+    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):
+    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):
+    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):
+    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)
@@ -488,14 +501,14 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_pre_listing(self, token):
+    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):
+    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
@@ -505,7 +518,7 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_button(self, token):
+    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")
@@ -513,19 +526,19 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_paragraph(self, token):
+    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):
+    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):
+    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)
@@ -533,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):
+    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"):
@@ -541,7 +554,7 @@ class TreeBuilderModesMixin:
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_dd_dt(self, token):
+    def _handle_body_start_dd_dt(self, token: Tag) -> None:
         self.frameset_ok = False
         self._close_p_element()
         name = token.name
@@ -558,7 +571,7 @@ class TreeBuilderModesMixin:
         self._insert_element(token, push=True)
         return
 
-    def _adoption_agency(self, subject):
+    def _adoption_agency(self, subject: Any) -> None:
         # 1. If the current node is the subject, and it is not in the active formatting elements list...
         if self.open_elements and self.open_elements[-1].name == subject:
             if not self._has_active_formatting_entry(subject):
@@ -570,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]
@@ -647,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
@@ -680,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
@@ -702,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):
+    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")
@@ -712,7 +738,7 @@ class TreeBuilderModesMixin:
         self._append_active_formatting_entry("a", token.attrs, node)
         return
 
-    def _handle_body_start_formatting(self, token):
+    def _handle_body_start_formatting(self, token: Tag) -> None:
         name = token.name
         if name == "nobr" and self._in_scope("nobr"):
             self._adoption_agency("nobr")
@@ -726,21 +752,21 @@ class TreeBuilderModesMixin:
         self._append_active_formatting_entry(name, token.attrs, node)
         return
 
-    def _handle_body_start_applet_like(self, token):
+    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):
+    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):
+    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
@@ -765,17 +791,17 @@ class TreeBuilderModesMixin:
     # Body mode end tag handlers
     # ---------------------
 
-    def _handle_body_end_body(self, token):
+    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):
+    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):
+    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)
@@ -783,21 +809,21 @@ class TreeBuilderModesMixin:
             self._close_p_element()
         return
 
-    def _handle_body_end_li(self, token):
+    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):
+    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):
+    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
@@ -807,7 +833,7 @@ class TreeBuilderModesMixin:
             self._parse_error("unexpected-end-tag", tag_name=token.name)
         return
 
-    def _handle_body_end_applet_like(self, token):
+    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)
@@ -820,7 +846,7 @@ class TreeBuilderModesMixin:
         self._clear_active_formatting_up_to_marker()
         return
 
-    def _handle_body_end_heading(self, token):
+    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)
@@ -835,7 +861,7 @@ class TreeBuilderModesMixin:
                 break
         return
 
-    def _handle_body_end_block(self, token):
+    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)
@@ -846,9 +872,10 @@ class TreeBuilderModesMixin:
         self._pop_until_any_inclusive({name})
         return
 
-    def _handle_body_end_template(self, token):
+    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")
@@ -859,18 +886,18 @@ class TreeBuilderModesMixin:
         self._reset_insertion_mode()
         return
 
-    def _handle_body_start_structure_ignored(self, token):
+    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):
+    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):
+    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()
@@ -878,17 +905,17 @@ class TreeBuilderModesMixin:
         self.frameset_ok = False
         return
 
-    def _handle_body_start_void_with_formatting(self, token):
+    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):
+    def _handle_body_start_simple_void(self, token: Tag) -> None:
         self._insert_element(token, push=False)
         return
 
-    def _handle_body_start_input(self, token):
+    def _handle_body_start_input(self, token: Tag) -> None:
         input_type = None
         for name, value in token.attrs.items():
             if name == "type":
@@ -899,7 +926,7 @@ class TreeBuilderModesMixin:
             self.frameset_ok = False
         return
 
-    def _handle_body_start_table(self, token):
+    def _handle_body_start_table(self, token: Tag) -> None:
         if self.quirks_mode != "quirks":
             self._close_p_element()
         self._insert_element(token, push=True)
@@ -907,7 +934,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_TABLE
         return
 
-    def _handle_body_start_plaintext_xmp(self, token):
+    def _handle_body_start_plaintext_xmp(self, token: Tag) -> None:
         self._close_p_element()
         self._insert_element(token, push=True)
         self.frameset_ok = False
@@ -919,66 +946,88 @@ class TreeBuilderModesMixin:
             self.mode = InsertionMode.TEXT
         return
 
-    def _handle_body_start_textarea(self, token):
+    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):
+    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):
+    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._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_optgroup(self, token):
+    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._reconstruct_active_formatting_elements()
         self._insert_element(token, push=True)
         return
 
-    def _handle_body_start_rp_rt(self, token):
+    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):
+    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):
+    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):
+    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):
+    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
@@ -1051,7 +1100,7 @@ class TreeBuilderModesMixin:
                         self.form_element = node
                         self.open_elements.pop()  # 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:
@@ -1078,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):
+    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):
+    def _mode_in_caption(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             return self._mode_in_body(token)
         if isinstance(token, CommentToken):
@@ -1136,7 +1199,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return self._mode_in_body(token)
 
-    def _close_caption_element(self):
+    def _close_caption_element(self) -> bool:
         if not self._has_in_table_scope("caption"):
             self._parse_error("unexpected-end-tag", tag_name="caption")
             return False
@@ -1150,7 +1213,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_TABLE
         return True
 
-    def _mode_in_column_group(self, token):
+    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 ""
@@ -1245,7 +1308,7 @@ class TreeBuilderModesMixin:
         return None
         # Per spec: EOF when current is html - implicit None return
 
-    def _mode_in_table_body(self, token):
+    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):
@@ -1321,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):
+    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):
@@ -1370,7 +1433,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return self._mode_in_table(token)
 
-    def _end_tr_element(self):
+    def _end_tr_element(self) -> None:
         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":
@@ -1381,7 +1444,7 @@ class TreeBuilderModesMixin:
         else:
             self.mode = InsertionMode.IN_TABLE_BODY
 
-    def _mode_in_cell(self, token):
+    def _mode_in_cell(self, token: AnyToken) -> ModeResultTuple | None:
         if isinstance(token, CharacterTokens):
             previous = self.insert_from_table
             self.insert_from_table = False
@@ -1435,15 +1498,11 @@ class TreeBuilderModesMixin:
             return ("reprocess", self.mode, token)
         return self._mode_in_table(token)
 
-    def _mode_in_select(self, token):
+    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)
@@ -1471,13 +1530,13 @@ class TreeBuilderModesMixin:
                     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()
@@ -1487,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()
@@ -1505,6 +1564,7 @@ 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()
@@ -1514,22 +1574,29 @@ class TreeBuilderModesMixin:
                     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":
@@ -1537,13 +1604,13 @@ class TreeBuilderModesMixin:
                 if self.open_elements and self.open_elements[-1].name == "optgroup":
                     self.open_elements.pop()
                 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()
                 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
@@ -1555,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
@@ -1582,11 +1652,9 @@ class TreeBuilderModesMixin:
                         popped = self.open_elements.pop()
                         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()
@@ -1597,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):
+    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):
@@ -1676,7 +1744,7 @@ class TreeBuilderModesMixin:
             return ("reprocess", self.mode, token)
         return None
 
-    def _mode_after_body(self, token):
+    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)
@@ -1697,7 +1765,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return None
 
-    def _mode_after_after_body(self, token):
+    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
@@ -1724,7 +1792,7 @@ class TreeBuilderModesMixin:
         assert isinstance(token, EOFToken), f"Unexpected token type: {type(token)}"
         return None
 
-    def _mode_in_frameset(self, token):
+    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
@@ -1766,11 +1834,14 @@ class TreeBuilderModesMixin:
         self._parse_error("unexpected-token-in-frameset")
         return None
 
-    def _mode_after_frameset(self, token):
+    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
@@ -1783,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)
@@ -1795,7 +1869,7 @@ class TreeBuilderModesMixin:
         self.mode = InsertionMode.IN_FRAMESET
         return ("reprocess", InsertionMode.IN_FRAMESET, token)
 
-    def _mode_after_after_frameset(self, token):
+    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
@@ -1826,7 +1900,7 @@ class TreeBuilderModesMixin:
 
     # Helpers ----------------------------------------------------------------
 
-    _MODE_HANDLERS = [
+    _MODE_HANDLERS: list[Callable[[TreeBuilderModesMixin, AnyToken], ModeResultTuple | None]] = [
         _mode_initial,
         _mode_before_html,
         _mode_before_head,
@@ -1851,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,
@@ -1963,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,