rearrange to be wrapped under one Htmlrw module

lib/dom/dune

···
-(library
- (name html5rw_dom)
- (public_name html5rw.dom)
- (libraries bytesrw))

lib/dom/html5rw_dom.ml lib/html5rw/dom/dom.ml

···
     and serialization.
 *)
 
-include Node
+include Dom_node
 
-let to_html = Serialize.to_html
-let to_writer = Serialize.to_writer
-let to_test_format = Serialize.to_test_format
-let to_text = Serialize.to_text
+let to_html = Dom_serialize.to_html
+let to_writer = Dom_serialize.to_writer
+let to_test_format = Dom_serialize.to_test_format
+let to_text = Dom_serialize.to_text

lib/dom/html5rw_dom.mli lib/html5rw/dom/dom.mli

···
     @see <https://html.spec.whatwg.org/multipage/parsing.html#the-initial-insertion-mode>
          WHATWG: DOCTYPE handling during parsing
 *)
-type doctype_data = Node.doctype_data = {
+type doctype_data = Dom_node.doctype_data = {
   name : string option;       (** The DOCTYPE name, e.g., "html" *)
   public_id : string option;  (** Public identifier (legacy, rarely used) *)
   system_id : string option;  (** System identifier (legacy, rarely used) *)
···
     @see <https://html.spec.whatwg.org/multipage/parsing.html#the-initial-insertion-mode>
          WHATWG: How the parser determines quirks mode
 *)
-type quirks_mode = Node.quirks_mode = No_quirks | Quirks | Limited_quirks
+type quirks_mode = Dom_node.quirks_mode = No_quirks | Quirks | Limited_quirks
 
 (** A DOM node in the parsed document tree.
 
···
     @see <https://html.spec.whatwg.org/multipage/scripting.html#the-template-element>
          WHATWG: The template element
 *)
-type node = Node.node = {
+type node = Dom_node.node = {
   mutable name : string;
   (** Tag name for elements, or special name for other node types.
 

lib/dom/serialize.ml lib/html5rw/dom/dom_serialize.ml

···
 (* HTML5 DOM serialization *)
 
 open Bytesrw
-open Node
+open Dom_node
 
 (* Void elements that don't have end tags *)
 let void_elements = [

lib/encoding/bom.ml lib/html5rw/encoding/encoding_bom.ml

···
      Bytes.get data 0 = '\xEF' &&
      Bytes.get data 1 = '\xBB' &&
      Bytes.get data 2 = '\xBF' then
-    Some (Encoding.Utf8, 3)
+    Some (Encoding_types.Utf8, 3)
   else if len >= 2 &&
           Bytes.get data 0 = '\xFF' &&
           Bytes.get data 1 = '\xFE' then
-    Some (Encoding.Utf16le, 2)
+    Some (Encoding_types.Utf16le, 2)
   else if len >= 2 &&
           Bytes.get data 0 = '\xFE' &&
           Bytes.get data 1 = '\xFF' then
-    Some (Encoding.Utf16be, 2)
+    Some (Encoding_types.Utf16be, 2)
   else
     None

lib/encoding/decode.ml lib/html5rw/encoding/encoding_decode.ml

···
 
 let decode_with_encoding data enc ~bom_len =
   match enc with
-  | Encoding.Utf8 ->
+  | Encoding_types.Utf8 ->
     (* UTF-8: Just validate and replace errors with replacement character *)
     let len = Bytes.length data in
     let buf = Buffer.create len in
···
     loop ();
     Buffer.contents buf
 
-  | Encoding.Utf16le -> decode_utf16 data ~is_le:true ~bom_len
-  | Encoding.Utf16be -> decode_utf16 data ~is_le:false ~bom_len
+  | Encoding_types.Utf16le -> decode_utf16 data ~is_le:true ~bom_len
+  | Encoding_types.Utf16be -> decode_utf16 data ~is_le:false ~bom_len
 
-  | Encoding.Windows_1252 ->
+  | Encoding_types.Windows_1252 ->
     (* Windows-1252 mapping table for 0x80-0x9F range *)
     let len = Bytes.length data in
     let buf = Buffer.create len in
···
     done;
     Buffer.contents buf
 
-  | Encoding.Iso_8859_2 ->
+  | Encoding_types.Iso_8859_2 ->
     (* Use uuuu for ISO-8859-2 decoding *)
     let len = Bytes.length data in
     let buf = Buffer.create len in
···
     ) () s;
     Buffer.contents buf
 
-  | Encoding.Euc_jp ->
+  | Encoding_types.Euc_jp ->
     (* For EUC-JP, use uutf with best effort *)
     let len = Bytes.length data in
     let buf = Buffer.create len in
···
 
 let decode data ?transport_encoding () =
   (* Step 1: Check for BOM *)
-  let bom_result = Bom.sniff data in
+  let bom_result = Encoding_bom.sniff data in
   match bom_result with
   | Some (enc, bom_len) ->
     (decode_with_encoding data enc ~bom_len, enc)
···
     (* Step 2: Check transport encoding (e.g., HTTP Content-Type) *)
     let enc_from_transport =
       match transport_encoding with
-      | Some te -> Labels.normalize_label te
+      | Some te -> Encoding_labels.normalize_label te
       | None -> None
     in
     match enc_from_transport with
     | Some enc -> (decode_with_encoding data enc ~bom_len:0, enc)
     | None ->
       (* Step 3: Prescan for meta charset *)
-      match Prescan.prescan_for_meta_charset data with
+      match Encoding_prescan.prescan_for_meta_charset data with
       | Some enc -> (decode_with_encoding data enc ~bom_len:0, enc)
       | None ->
         (* Default to Windows-1252 per HTML5 spec when no encoding detected *)
-        (decode_with_encoding data Encoding.Windows_1252 ~bom_len:0, Encoding.Windows_1252)
+        (decode_with_encoding data Encoding_types.Windows_1252 ~bom_len:0, Encoding_types.Windows_1252)

lib/encoding/dune

···
-(library
- (name html5rw_encoding)
- (public_name html5rw.encoding)
- (libraries astring bytesrw uutf uuuu))

lib/encoding/html5rw_encoding.ml lib/html5rw/encoding/encoding.ml

···
     encodings, but this implementation focuses on the most common ones.
     Other encodings are mapped to their closest equivalent.
 *)
-type encoding = Encoding.t =
+type encoding = Encoding_types.t =
   | Utf8         (** UTF-8 encoding (default) *)
   | Utf16le      (** UTF-16 little-endian *)
   | Utf16be      (** UTF-16 big-endian *)
···
 
     Returns the WHATWG canonical name, e.g., ["utf-8"], ["utf-16le"].
 *)
-let encoding_to_string = Encoding.to_string
+let encoding_to_string = Encoding_types.to_string
 
 (** Detect encoding from a byte order mark.
 
···
     @return [(Some (encoding, skip_bytes))] if a BOM is found,
             [None] otherwise.
 *)
-let sniff_bom = Bom.sniff
+let sniff_bom = Encoding_bom.sniff
 
 (** Normalize an encoding label to its canonical form.
 
···
       normalize_label "latin1"     (* Some Windows_1252 *)
     ]}
 *)
-let normalize_label = Labels.normalize_label
+let normalize_label = Encoding_labels.normalize_label
 
 (** Prescan bytes to find a meta charset declaration.
 
···
 
     @return [Some encoding] if a meta charset is found, [None] otherwise.
 *)
-let prescan_for_meta_charset = Prescan.prescan_for_meta_charset
+let prescan_for_meta_charset = Encoding_prescan.prescan_for_meta_charset
 
 (** {1 Decoding} *)
 
···
       (* html is now a UTF-8 string, enc is the detected encoding *)
     ]}
 *)
-let decode = Decode.decode
+let decode = Encoding_decode.decode

lib/encoding/html5rw_encoding.mli lib/html5rw/encoding/encoding.mli

···
     encodings, but this implementation focuses on the most common ones.
     Other encodings are mapped to their closest equivalent.
 *)
-type encoding = Encoding.t =
+type encoding = Encoding_types.t =
   | Utf8         (** UTF-8 encoding (default) *)
   | Utf16le      (** UTF-16 little-endian *)
   | Utf16be      (** UTF-16 big-endian *)

lib/encoding/labels.ml lib/html5rw/encoding/encoding_labels.ml

···
     else
       (* Security: never allow utf-7 *)
       if s = "utf-7" || s = "utf7" || s = "x-utf-7" then
-        Some Encoding.Windows_1252
+        Some Encoding_types.Windows_1252
       else if s = "utf-8" || s = "utf8" then
-        Some Encoding.Utf8
+        Some Encoding_types.Utf8
       (* HTML treats latin-1 labels as windows-1252 *)
       else if s = "iso-8859-1" || s = "iso8859-1" || s = "latin1" ||
               s = "latin-1" || s = "l1" || s = "cp819" || s = "ibm819" then
-        Some Encoding.Windows_1252
+        Some Encoding_types.Windows_1252
       else if s = "windows-1252" || s = "windows1252" || s = "cp1252" || s = "x-cp1252" then
-        Some Encoding.Windows_1252
+        Some Encoding_types.Windows_1252
       else if s = "iso-8859-2" || s = "iso8859-2" || s = "latin2" || s = "latin-2" then
-        Some Encoding.Iso_8859_2
+        Some Encoding_types.Iso_8859_2
       else if s = "euc-jp" || s = "eucjp" then
-        Some Encoding.Euc_jp
+        Some Encoding_types.Euc_jp
       else if s = "utf-16" || s = "utf16" then
-        Some Encoding.Utf16le  (* Default to LE for ambiguous utf-16 *)
+        Some Encoding_types.Utf16le  (* Default to LE for ambiguous utf-16 *)
       else if s = "utf-16le" || s = "utf16le" then
-        Some Encoding.Utf16le
+        Some Encoding_types.Utf16le
       else if s = "utf-16be" || s = "utf16be" then
-        Some Encoding.Utf16be
+        Some Encoding_types.Utf16be
       else
         None
 
···
     (* Per HTML meta charset handling: ignore UTF-16/UTF-32 declarations and
        treat them as UTF-8 *)
     match enc with
-    | Encoding.Utf16le | Encoding.Utf16be -> Some Encoding.Utf8
+    | Encoding_types.Utf16le | Encoding_types.Utf16be -> Some Encoding_types.Utf8
     | other -> Some other

lib/encoding/prescan.ml lib/html5rw/encoding/encoding_prescan.ml

···
             (* Check for charset *)
             (match !charset with
             | Some cs ->
-              (match Labels.normalize_meta_declared cs with
+              (match Encoding_labels.normalize_meta_declared cs with
               | Some enc -> result := Some enc
               | None -> ())
             | None -> ());
···
               | Some he, Some ct when String.lowercase_ascii he = "content-type" ->
                 (match extract_charset_from_content ct with
                 | Some extracted ->
-                  (match Labels.normalize_meta_declared extracted with
+                  (match Encoding_labels.normalize_meta_declared extracted with
                   | Some enc -> result := Some enc
                   | None -> ())
                 | None -> ())

lib/entities/decode.ml lib/html5rw/entities/entities_decode.ml

···
         let digit_text = String.sub text digit_start (!j - digit_start) in
 
         if String.length digit_text > 0 then begin
-          match Numeric_ref.decode digit_text ~is_hex with
+          match Entities_numeric_ref.decode digit_text ~is_hex with
           | Some decoded ->
             Buffer.add_string buf decoded;
             i := if has_semicolon then !j + 1 else !j
···
           (* Try exact match first (with semicolon expected) *)
           let decoded =
             if has_semicolon then
-              Entity_table.lookup entity_name
+              Entities_entity_table.lookup entity_name
             else
               None
           in
···
                 if k <= 0 then None
                 else
                   let prefix = String.sub entity_name 0 k in
-                  if Entity_table.is_legacy prefix then
-                    match Entity_table.lookup prefix with
+                  if Entities_entity_table.is_legacy prefix then
+                    match Entities_entity_table.lookup prefix with
                     | Some value -> Some (value, k)
                     | None -> try_prefix (k - 1)
                   else
···
                 i := !j + 1
             end else if not has_semicolon then begin
               (* Try without semicolon for legacy compatibility *)
-              if Entity_table.is_legacy entity_name then
-                match Entity_table.lookup entity_name with
+              if Entities_entity_table.is_legacy entity_name then
+                match Entities_entity_table.lookup entity_name with
                 | Some value ->
                   (* Legacy entities without semicolon have strict rules in attributes *)
                   let next_char = if !j < len then Some text.[!j] else None in
···
                   if k <= 0 then None
                   else
                     let prefix = String.sub entity_name 0 k in
-                    if Entity_table.is_legacy prefix then
-                      match Entity_table.lookup prefix with
+                    if Entities_entity_table.is_legacy prefix then
+                      match Entities_entity_table.lookup prefix with
                       | Some value -> Some (value, k)
                       | None -> try_prefix (k - 1)
                     else

lib/entities/dune

···
-(library
- (name html5rw_entities)
- (public_name html5rw.entities)
- (libraries astring uutf))
-
-(rule
- (target entity_table.ml)
- (deps ../../data/entities.json)
- (action (run ../../gen/gen_entities.exe %{deps} %{target})))

lib/entities/html5rw_entities.ml lib/html5rw/entities/entities.ml

···
       (* Returns: "<script>" *)
     ]}
 *)
-let decode = Decode.decode_entities_in_text
+let decode = Entities_decode.decode_entities_in_text
 
 (** Decode a numeric character reference.
 
···
     specification (e.g., control characters in the 0x80-0x9F range
     are mapped to Windows-1252 equivalents).
 *)
-let decode_numeric = Numeric_ref.decode
+let decode_numeric = Entities_numeric_ref.decode
 
 (** Look up a named character reference.
 
···
       lookup "bogus"  (* None *)
     ]}
 *)
-let lookup = Entity_table.lookup
+let lookup = Entities_entity_table.lookup
 
 (** Check if an entity is a legacy entity.
 
···
       is_legacy "Aacute" (* false - requires semicolon *)
     ]}
 *)
-let is_legacy = Entity_table.is_legacy
+let is_legacy = Entities_entity_table.is_legacy
 
 (** Convert a Unicode codepoint to its UTF-8 encoding.
 
     @param codepoint The Unicode codepoint (0 to 0x10FFFF)
     @return The UTF-8 encoded string
 *)
-let codepoint_to_utf8 = Numeric_ref.codepoint_to_utf8
+let codepoint_to_utf8 = Entities_numeric_ref.codepoint_to_utf8
 
 (** {1 Sub-modules} *)
 
 (** Numeric character reference handling. *)
-module Numeric_ref = Numeric_ref
+module Numeric_ref = Entities_numeric_ref

lib/html5rw/dune

···
+(include_subdirs unqualified)
+
 (library
  (name html5rw)
  (public_name html5rw)
- (libraries
-  bytesrw
-  html5rw.parser
-  html5rw.dom
-  html5rw.tokenizer
-  html5rw.encoding
-  html5rw.selector
-  html5rw.entities))
+ (libraries astring bytesrw uutf uuuu))

lib/html5rw/entities/dune

···
+(rule
+ (target entities_entity_table.ml)
+ (deps ../../../data/entities.json)
+ (action (run ../../../gen/gen_entities.exe %{deps} %{target})))

lib/html5rw/html5rw.ml

···
 (** {1 Sub-modules} *)
 
 (** DOM types and manipulation functions *)
-module Dom = Html5rw_dom
+module Dom = Dom
 
 (** HTML5 tokenizer *)
-module Tokenizer = Html5rw_tokenizer
+module Tokenizer = Tokenizer
 
 (** Encoding detection and decoding *)
-module Encoding = Html5rw_encoding
+module Encoding = Encoding
 
 (** CSS selector engine *)
-module Selector = Html5rw_selector
+module Selector = Selector
 
 (** HTML entity decoding *)
-module Entities = Html5rw_entities
+module Entities = Entities
 
 (** Low-level parser access *)
-module Parser = Html5rw_parser
+module Parser = Parser
 
 (** {1 Core Types} *)
 

lib/html5rw/html5rw.mli

···
 
     @see <https://html.spec.whatwg.org/multipage/dom.html>
          WHATWG: The elements of HTML *)
-module Dom = Html5rw_dom
+module Dom = Dom
 
 (** HTML5 tokenizer.
 
···
 
     @see <https://html.spec.whatwg.org/multipage/parsing.html#tokenization>
          WHATWG: Tokenization *)
-module Tokenizer = Html5rw_tokenizer
+module Tokenizer = Tokenizer
 
 (** Encoding detection and decoding.
 
···
          WHATWG: Determining the character encoding
     @see <https://encoding.spec.whatwg.org/>
          WHATWG Encoding Standard *)
-module Encoding = Html5rw_encoding
+module Encoding = Encoding
 
 (** CSS selector engine.
 
···
 
     @see <https://www.w3.org/TR/selectors-4/>
          W3C Selectors Level 4 specification *)
-module Selector = Html5rw_selector
+module Selector = Selector
 
 (** HTML entity decoding.
 
···
 
     @see <https://html.spec.whatwg.org/multipage/named-characters.html>
          WHATWG: Named character references *)
-module Entities = Html5rw_entities
+module Entities = Entities
 
 (** Low-level parser access.
 
···
 
     @see <https://html.spec.whatwg.org/multipage/parsing.html#tree-construction>
          WHATWG: Tree construction *)
-module Parser = Html5rw_parser
+module Parser = Parser
 
 (** {1 Core Types} *)
 

lib/html5rw/parser/parser.ml

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+(* html5rw.parser - HTML5 parser with bytesrw-only API *)
+
+module Dom = Dom
+module Tokenizer = Tokenizer
+module Encoding = Encoding
+module Constants = Parser_constants
+module Insertion_mode = Parser_insertion_mode
+module Tree_builder = Parser_tree_builder
+
+type parse_error = Parser_impl.parse_error
+type fragment_context = Parser_impl.fragment_context
+type t = Parser_impl.t
+
+(* parse_error accessors *)
+let error_code (e : parse_error) = e.Parser_tree_builder.code
+let error_line (e : parse_error) = e.Parser_tree_builder.line
+let error_column (e : parse_error) = e.Parser_tree_builder.column
+
+(* fragment_context constructor and accessors *)
+let make_fragment_context ~tag_name ?(namespace=None) () : fragment_context =
+  { Parser_tree_builder.tag_name; namespace }
+
+let fragment_context_tag (ctx : fragment_context) = ctx.Parser_tree_builder.tag_name
+let fragment_context_namespace (ctx : fragment_context) = ctx.Parser_tree_builder.namespace
+
+let parse = Parser_impl.parse
+let parse_bytes = Parser_impl.parse_bytes
+let query = Parser_impl.query
+let to_writer = Parser_impl.to_writer
+let to_string = Parser_impl.to_string
+let to_text = Parser_impl.to_text
+let to_test_format = Parser_impl.to_test_format
+
+let root t = t.Parser_impl.root
+let errors t = t.Parser_impl.errors
+let encoding t = t.Parser_impl.encoding

lib/html5rw/tokenizer/tokenizer.ml

···
+(* html5rw.tokenizer - HTML5 tokenizer with bytesrw-only API *)
+
+module Token = Tokenizer_token
+module State = Tokenizer_state
+module Errors = Tokenizer_errors
+module Stream = Tokenizer_stream
+
+module type SINK = Tokenizer_impl.SINK
+
+type 'a t = 'a Tokenizer_impl.t
+
+let create = Tokenizer_impl.create
+let run = Tokenizer_impl.run
+let get_errors = Tokenizer_impl.get_errors
+let set_state = Tokenizer_impl.set_state
+let set_last_start_tag = Tokenizer_impl.set_last_start_tag

lib/html5rw/tokenizer/tokenizer_impl.ml

···
+(* HTML5 Tokenizer - implements WHATWG tokenization algorithm *)
+
+(* Character classification using Astring *)
+let is_ascii_alpha = Astring.Char.Ascii.is_letter
+let is_ascii_digit = Astring.Char.Ascii.is_digit
+let is_ascii_hex = Astring.Char.Ascii.is_hex_digit
+let is_ascii_alnum = Astring.Char.Ascii.is_alphanum
+let is_whitespace c = c = ' ' || c = '\t' || c = '\n' || c = '\x0C' || c = '\r'
+let ascii_lower = Astring.Char.Ascii.lowercase
+
+(* Token sink interface *)
+module type SINK = sig
+  type t
+  val process : t -> Tokenizer_token.t -> [ `Continue | `SwitchTo of Tokenizer_state.t ]
+  val adjusted_current_node_in_html_namespace : t -> bool
+end
+
+type 'sink t = {
+  mutable stream : Tokenizer_stream.t;
+  sink : 'sink;
+  mutable state : Tokenizer_state.t;
+  mutable return_state : Tokenizer_state.t;
+  mutable char_ref_code : int;
+  mutable temp_buffer : Buffer.t;
+  mutable last_start_tag : string;
+  mutable current_tag_name : Buffer.t;
+  mutable current_tag_kind : Tokenizer_token.tag_kind;
+  mutable current_tag_self_closing : bool;
+  mutable current_attr_name : Buffer.t;
+  mutable current_attr_value : Buffer.t;
+  mutable current_attrs : (string * string) list;
+  mutable current_doctype_name : Buffer.t option;
+  mutable current_doctype_public : Buffer.t option;
+  mutable current_doctype_system : Buffer.t option;
+  mutable current_doctype_force_quirks : bool;
+  mutable current_comment : Buffer.t;
+  mutable pending_chars : Buffer.t;
+  mutable errors : Tokenizer_errors.t list;
+  collect_errors : bool;
+  xml_mode : bool;  (* XML violation mode: transform chars for XML compatibility *)
+}
+
+let create (type s) (module S : SINK with type t = s) sink ?(collect_errors=false) ?(xml_mode=false) () = {
+  stream = Tokenizer_stream.create "";
+  sink;
+  state = Tokenizer_state.Data;
+  return_state = Tokenizer_state.Data;
+  char_ref_code = 0;
+  temp_buffer = Buffer.create 64;
+  last_start_tag = "";
+  current_tag_name = Buffer.create 32;
+  current_tag_kind = Tokenizer_token.Start;
+  current_tag_self_closing = false;
+  current_attr_name = Buffer.create 32;
+  current_attr_value = Buffer.create 64;
+  current_attrs = [];
+  current_doctype_name = None;
+  current_doctype_public = None;
+  current_doctype_system = None;
+  current_doctype_force_quirks = false;
+  current_comment = Buffer.create 64;
+  pending_chars = Buffer.create 256;
+  errors = [];
+  collect_errors;
+  xml_mode;
+}
+
+let error t code =
+  if t.collect_errors then begin
+    let (line, column) = Tokenizer_stream.position t.stream in
+    t.errors <- Tokenizer_errors.make ~code ~line ~column :: t.errors
+  end
+
+(* emit functions are defined locally inside run *)
+
+(* XML mode character transformation: form feed → space *)
+let emit_char t c =
+  if t.xml_mode && c = '\x0C' then
+    Buffer.add_char t.pending_chars ' '
+  else
+    Buffer.add_char t.pending_chars c
+
+(* XML mode string transformation: U+FFFF → U+FFFD, form feed → space *)
+let emit_str t s =
+  if t.xml_mode then begin
+    (* Transform: \xEF\xBF\xBF (U+FFFF) → \xEF\xBF\xBD (U+FFFD), \x0C → space *)
+    let len = String.length s in
+    let i = ref 0 in
+    while !i < len do
+      let c = s.[!i] in
+      if c = '\x0C' then begin
+        Buffer.add_char t.pending_chars ' ';
+        incr i
+      end else if c = '\xEF' && !i + 2 < len && s.[!i+1] = '\xBF' && s.[!i+2] = '\xBF' then begin
+        (* U+FFFF → U+FFFD *)
+        Buffer.add_string t.pending_chars "\xEF\xBF\xBD";
+        i := !i + 3
+      end else begin
+        Buffer.add_char t.pending_chars c;
+        incr i
+      end
+    done
+  end else
+    Buffer.add_string t.pending_chars s
+
+let start_new_tag t kind =
+  Buffer.clear t.current_tag_name;
+  t.current_tag_kind <- kind;
+  t.current_tag_self_closing <- false;
+  t.current_attrs <- []
+
+let start_new_attribute t =
+  (* Save previous attribute if any *)
+  let name = Buffer.contents t.current_attr_name in
+  if String.length name > 0 then begin
+    let value = Buffer.contents t.current_attr_value in
+    (* Check for duplicates - only add if not already present *)
+    if not (List.exists (fun (n, _) -> n = name) t.current_attrs) then
+      t.current_attrs <- (name, value) :: t.current_attrs
+    else
+      error t "duplicate-attribute"
+  end;
+  Buffer.clear t.current_attr_name;
+  Buffer.clear t.current_attr_value
+
+let finish_attribute t =
+  start_new_attribute t
+
+let start_new_doctype t =
+  t.current_doctype_name <- None;
+  t.current_doctype_public <- None;
+  t.current_doctype_system <- None;
+  t.current_doctype_force_quirks <- false
+
+(* emit_current_tag, emit_current_doctype, emit_current_comment are defined locally inside run *)
+
+let is_appropriate_end_tag t =
+  let name = Buffer.contents t.current_tag_name in
+  String.length t.last_start_tag > 0 && name = t.last_start_tag
+
+let flush_code_points_consumed_as_char_ref t =
+  let s = Buffer.contents t.temp_buffer in
+  match t.return_state with
+  | Tokenizer_state.Attribute_value_double_quoted
+  | Tokenizer_state.Attribute_value_single_quoted
+  | Tokenizer_state.Attribute_value_unquoted ->
+    Buffer.add_string t.current_attr_value s
+  | _ ->
+    emit_str t s
+
+open Bytesrw
+
+(* Main tokenization loop *)
+let run (type s) t (module S : SINK with type t = s) (reader : Bytes.Reader.t) =
+  t.stream <- Tokenizer_stream.create_from_reader reader;
+  t.errors <- [];
+  (* Set up error callback for surrogate/noncharacter detection in stream *)
+  (* In XML mode, we don't report noncharacter errors - we transform them instead *)
+  if not t.xml_mode then
+    Tokenizer_stream.set_error_callback t.stream (fun code -> error t code);
+
+  (* XML mode transformation for pending chars: U+FFFF → U+FFFD *)
+  let transform_xml_chars data =
+    let len = String.length data in
+    let buf = Buffer.create len in
+    let i = ref 0 in
+    while !i < len do
+      let c = data.[!i] in
+      if c = '\xEF' && !i + 2 < len && data.[!i+1] = '\xBF' && data.[!i+2] = '\xBF' then begin
+        (* U+FFFF → U+FFFD *)
+        Buffer.add_string buf "\xEF\xBF\xBD";
+        i := !i + 3
+      end else begin
+        Buffer.add_char buf c;
+        incr i
+      end
+    done;
+    Buffer.contents buf
+  in
+
+  (* Local emit functions with access to S *)
+  let emit_pending_chars () =
+    if Buffer.length t.pending_chars > 0 then begin
+      let data = Buffer.contents t.pending_chars in
+      Buffer.clear t.pending_chars;
+      let data = if t.xml_mode then transform_xml_chars data else data in
+      ignore (S.process t.sink (Tokenizer_token.Character data))
+    end
+  in
+
+  let emit token =
+    emit_pending_chars ();
+    match S.process t.sink token with
+    | `Continue -> ()
+    | `SwitchTo new_state -> t.state <- new_state
+  in
+
+  let emit_current_tag () =
+    finish_attribute t;
+    let name = Buffer.contents t.current_tag_name in
+    let attrs = List.rev t.current_attrs in
+    (* Check for end tag with attributes or self-closing flag *)
+    if t.current_tag_kind = Tokenizer_token.End then begin
+      if attrs <> [] then
+        error t "end-tag-with-attributes";
+      if t.current_tag_self_closing then
+        error t "end-tag-with-trailing-solidus"
+    end;
+    let tag = {
+      Tokenizer_token.kind = t.current_tag_kind;
+      name;
+      attrs;
+      self_closing = t.current_tag_self_closing;
+    } in
+    if t.current_tag_kind = Tokenizer_token.Start then
+      t.last_start_tag <- name;
+    emit (Tokenizer_token.Tag tag)
+  in
+
+  let emit_current_doctype () =
+    let doctype = {
+      Tokenizer_token.name = Option.map Buffer.contents t.current_doctype_name;
+      public_id = Option.map Buffer.contents t.current_doctype_public;
+      system_id = Option.map Buffer.contents t.current_doctype_system;
+      force_quirks = t.current_doctype_force_quirks;
+    } in
+    emit (Tokenizer_token.Doctype doctype)
+  in
+
+  let emit_current_comment () =
+    let content = Buffer.contents t.current_comment in
+    let content =
+      if t.xml_mode then begin
+        (* XML mode: transform -- to - - in comments *)
+        let buf = Buffer.create (String.length content + 10) in
+        let len = String.length content in
+        let i = ref 0 in
+        while !i < len do
+          if !i + 1 < len && content.[!i] = '-' && content.[!i+1] = '-' then begin
+            Buffer.add_string buf "- -";
+            i := !i + 2
+          end else begin
+            Buffer.add_char buf content.[!i];
+            incr i
+          end
+        done;
+        Buffer.contents buf
+      end else content
+    in
+    emit (Tokenizer_token.Comment content)
+  in
+
+  (* Check for control characters and emit error if needed *)
+  (* Only checks ASCII control chars; C1 controls (U+0080-U+009F) are 2-byte in UTF-8 *)
+  let check_control_char c =
+    let code = Char.code c in
+    (* Control chars: U+0001-U+0008, U+000B, U+000E-U+001F, U+007F *)
+    (* Allowed: U+0009 (tab), U+000A (LF), U+000C (FF), U+000D (CR) *)
+    (* Note: U+0080-U+009F (C1 controls) are 2-byte UTF-8 sequences starting with 0xC2 *)
+    (* Note: We only check single-byte control chars here; multi-byte checks are TODO *)
+    if (code >= 0x01 && code <= 0x08) ||
+       code = 0x0B ||
+       (code >= 0x0E && code <= 0x1F) ||
+       code = 0x7F then
+      error t "control-character-in-input-stream"
+  in
+
+
+  (* Emit char with control character check *)
+  let emit_char_checked c =
+    check_control_char c;
+    emit_char t c
+  in
+
+  let rec process_state () =
+    if Tokenizer_stream.is_eof t.stream && t.state <> Tokenizer_state.Data then begin
+      (* Handle EOF in various states *)
+      handle_eof ()
+    end else if Tokenizer_stream.is_eof t.stream then begin
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    end else begin
+      step ();
+      process_state ()
+    end
+
+  and handle_eof () =
+    match t.state with
+    | Tokenizer_state.Data ->
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Tag_open ->
+      error t "eof-before-tag-name";
+      emit_char t '<';
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.End_tag_open ->
+      error t "eof-before-tag-name";
+      emit_str t "</";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Tag_name
+    | Tokenizer_state.Before_attribute_name
+    | Tokenizer_state.Attribute_name
+    | Tokenizer_state.After_attribute_name
+    | Tokenizer_state.Before_attribute_value
+    | Tokenizer_state.Attribute_value_double_quoted
+    | Tokenizer_state.Attribute_value_single_quoted
+    | Tokenizer_state.Attribute_value_unquoted
+    | Tokenizer_state.After_attribute_value_quoted
+    | Tokenizer_state.Self_closing_start_tag ->
+      error t "eof-in-tag";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rawtext ->
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rawtext_less_than_sign ->
+      emit_char t '<';
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rawtext_end_tag_open ->
+      emit_str t "</";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rawtext_end_tag_name ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rcdata ->
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rcdata_less_than_sign ->
+      emit_char t '<';
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rcdata_end_tag_open ->
+      emit_str t "</";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Rcdata_end_tag_name ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data ->
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_less_than_sign ->
+      emit_char t '<';
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_end_tag_open ->
+      emit_str t "</";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_end_tag_name ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_escape_start
+    | Tokenizer_state.Script_data_escape_start_dash
+    | Tokenizer_state.Script_data_escaped
+    | Tokenizer_state.Script_data_escaped_dash
+    | Tokenizer_state.Script_data_escaped_dash_dash ->
+      error t "eof-in-script-html-comment-like-text";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_escaped_less_than_sign ->
+      emit_char t '<';
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_escaped_end_tag_open ->
+      emit_str t "</";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_escaped_end_tag_name ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_double_escape_start
+    | Tokenizer_state.Script_data_double_escaped
+    | Tokenizer_state.Script_data_double_escaped_dash
+    | Tokenizer_state.Script_data_double_escaped_dash_dash ->
+      error t "eof-in-script-html-comment-like-text";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_double_escaped_less_than_sign ->
+      (* '<' was already emitted when entering this state from Script_data_double_escaped *)
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Script_data_double_escape_end ->
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Plaintext ->
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Comment_start
+    | Tokenizer_state.Comment_start_dash
+    | Tokenizer_state.Comment
+    | Tokenizer_state.Comment_less_than_sign
+    | Tokenizer_state.Comment_less_than_sign_bang
+    | Tokenizer_state.Comment_less_than_sign_bang_dash
+    | Tokenizer_state.Comment_less_than_sign_bang_dash_dash
+    | Tokenizer_state.Comment_end_dash
+    | Tokenizer_state.Comment_end
+    | Tokenizer_state.Comment_end_bang ->
+      error t "eof-in-comment";
+      emit_current_comment ();
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Bogus_comment ->
+      emit_current_comment ();
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Markup_declaration_open ->
+      error t "incorrectly-opened-comment";
+      Buffer.clear t.current_comment;
+      emit_current_comment ();
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Doctype
+    | Tokenizer_state.Before_doctype_name ->
+      error t "eof-in-doctype";
+      start_new_doctype t;
+      t.current_doctype_force_quirks <- true;
+      emit_current_doctype ();
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Doctype_name
+    | Tokenizer_state.After_doctype_name
+    | Tokenizer_state.After_doctype_public_keyword
+    | Tokenizer_state.Before_doctype_public_identifier
+    | Tokenizer_state.Doctype_public_identifier_double_quoted
+    | Tokenizer_state.Doctype_public_identifier_single_quoted
+    | Tokenizer_state.After_doctype_public_identifier
+    | Tokenizer_state.Between_doctype_public_and_system_identifiers
+    | Tokenizer_state.After_doctype_system_keyword
+    | Tokenizer_state.Before_doctype_system_identifier
+    | Tokenizer_state.Doctype_system_identifier_double_quoted
+    | Tokenizer_state.Doctype_system_identifier_single_quoted
+    | Tokenizer_state.After_doctype_system_identifier ->
+      error t "eof-in-doctype";
+      t.current_doctype_force_quirks <- true;
+      emit_current_doctype ();
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Bogus_doctype ->
+      emit_current_doctype ();
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Cdata_section ->
+      error t "eof-in-cdata";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Cdata_section_bracket ->
+      error t "eof-in-cdata";
+      emit_char t ']';
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Cdata_section_end ->
+      error t "eof-in-cdata";
+      emit_str t "]]";
+      emit_pending_chars ();
+      ignore (S.process t.sink Tokenizer_token.EOF)
+    | Tokenizer_state.Character_reference ->
+      (* state_character_reference never ran, so initialize temp_buffer with & *)
+      Buffer.clear t.temp_buffer;
+      Buffer.add_char t.temp_buffer '&';
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state;
+      handle_eof ()
+    | Tokenizer_state.Named_character_reference ->
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state;
+      handle_eof ()
+    | Tokenizer_state.Numeric_character_reference ->
+      (* At EOF with just "&#" - no digits follow *)
+      error t "absence-of-digits-in-numeric-character-reference";
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state;
+      handle_eof ()
+    | Tokenizer_state.Hexadecimal_character_reference_start
+    | Tokenizer_state.Decimal_character_reference_start ->
+      error t "absence-of-digits-in-numeric-character-reference";
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state;
+      handle_eof ()
+    | Tokenizer_state.Numeric_character_reference_end ->
+      (* We have collected digits, just need to finalize the character reference *)
+      step ();
+      handle_eof ()
+    | Tokenizer_state.Ambiguous_ampersand ->
+      (* Buffer was already flushed when entering this state, just transition *)
+      t.state <- t.return_state;
+      handle_eof ()
+    | Tokenizer_state.Hexadecimal_character_reference
+    | Tokenizer_state.Decimal_character_reference ->
+      (* At EOF with collected digits - convert the numeric reference *)
+      error t "missing-semicolon-after-character-reference";
+      let code = t.char_ref_code in
+      let replacement_char = "\xEF\xBF\xBD" in
+      let result =
+        if code = 0 then begin
+          error t "null-character-reference";
+          replacement_char
+        end else if code > 0x10FFFF then begin
+          error t "character-reference-outside-unicode-range";
+          replacement_char
+        end else if code >= 0xD800 && code <= 0xDFFF then begin
+          error t "surrogate-character-reference";
+          replacement_char
+        end else
+          Entities.Numeric_ref.codepoint_to_utf8 code
+      in
+      Buffer.clear t.temp_buffer;
+      Buffer.add_string t.temp_buffer result;
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state;
+      handle_eof ()
+
+  and step () =
+    match t.state with
+    | Tokenizer_state.Data -> state_data ()
+    | Tokenizer_state.Rcdata -> state_rcdata ()
+    | Tokenizer_state.Rawtext -> state_rawtext ()
+    | Tokenizer_state.Script_data -> state_script_data ()
+    | Tokenizer_state.Plaintext -> state_plaintext ()
+    | Tokenizer_state.Tag_open -> state_tag_open ()
+    | Tokenizer_state.End_tag_open -> state_end_tag_open ()
+    | Tokenizer_state.Tag_name -> state_tag_name ()
+    | Tokenizer_state.Rcdata_less_than_sign -> state_rcdata_less_than_sign ()
+    | Tokenizer_state.Rcdata_end_tag_open -> state_rcdata_end_tag_open ()
+    | Tokenizer_state.Rcdata_end_tag_name -> state_rcdata_end_tag_name ()
+    | Tokenizer_state.Rawtext_less_than_sign -> state_rawtext_less_than_sign ()
+    | Tokenizer_state.Rawtext_end_tag_open -> state_rawtext_end_tag_open ()
+    | Tokenizer_state.Rawtext_end_tag_name -> state_rawtext_end_tag_name ()
+    | Tokenizer_state.Script_data_less_than_sign -> state_script_data_less_than_sign ()
+    | Tokenizer_state.Script_data_end_tag_open -> state_script_data_end_tag_open ()
+    | Tokenizer_state.Script_data_end_tag_name -> state_script_data_end_tag_name ()
+    | Tokenizer_state.Script_data_escape_start -> state_script_data_escape_start ()
+    | Tokenizer_state.Script_data_escape_start_dash -> state_script_data_escape_start_dash ()
+    | Tokenizer_state.Script_data_escaped -> state_script_data_escaped ()
+    | Tokenizer_state.Script_data_escaped_dash -> state_script_data_escaped_dash ()
+    | Tokenizer_state.Script_data_escaped_dash_dash -> state_script_data_escaped_dash_dash ()
+    | Tokenizer_state.Script_data_escaped_less_than_sign -> state_script_data_escaped_less_than_sign ()
+    | Tokenizer_state.Script_data_escaped_end_tag_open -> state_script_data_escaped_end_tag_open ()
+    | Tokenizer_state.Script_data_escaped_end_tag_name -> state_script_data_escaped_end_tag_name ()
+    | Tokenizer_state.Script_data_double_escape_start -> state_script_data_double_escape_start ()
+    | Tokenizer_state.Script_data_double_escaped -> state_script_data_double_escaped ()
+    | Tokenizer_state.Script_data_double_escaped_dash -> state_script_data_double_escaped_dash ()
+    | Tokenizer_state.Script_data_double_escaped_dash_dash -> state_script_data_double_escaped_dash_dash ()
+    | Tokenizer_state.Script_data_double_escaped_less_than_sign -> state_script_data_double_escaped_less_than_sign ()
+    | Tokenizer_state.Script_data_double_escape_end -> state_script_data_double_escape_end ()
+    | Tokenizer_state.Before_attribute_name -> state_before_attribute_name ()
+    | Tokenizer_state.Attribute_name -> state_attribute_name ()
+    | Tokenizer_state.After_attribute_name -> state_after_attribute_name ()
+    | Tokenizer_state.Before_attribute_value -> state_before_attribute_value ()
+    | Tokenizer_state.Attribute_value_double_quoted -> state_attribute_value_double_quoted ()
+    | Tokenizer_state.Attribute_value_single_quoted -> state_attribute_value_single_quoted ()
+    | Tokenizer_state.Attribute_value_unquoted -> state_attribute_value_unquoted ()
+    | Tokenizer_state.After_attribute_value_quoted -> state_after_attribute_value_quoted ()
+    | Tokenizer_state.Self_closing_start_tag -> state_self_closing_start_tag ()
+    | Tokenizer_state.Bogus_comment -> state_bogus_comment ()
+    | Tokenizer_state.Markup_declaration_open -> state_markup_declaration_open ()
+    | Tokenizer_state.Comment_start -> state_comment_start ()
+    | Tokenizer_state.Comment_start_dash -> state_comment_start_dash ()
+    | Tokenizer_state.Comment -> state_comment ()
+    | Tokenizer_state.Comment_less_than_sign -> state_comment_less_than_sign ()
+    | Tokenizer_state.Comment_less_than_sign_bang -> state_comment_less_than_sign_bang ()
+    | Tokenizer_state.Comment_less_than_sign_bang_dash -> state_comment_less_than_sign_bang_dash ()
+    | Tokenizer_state.Comment_less_than_sign_bang_dash_dash -> state_comment_less_than_sign_bang_dash_dash ()
+    | Tokenizer_state.Comment_end_dash -> state_comment_end_dash ()
+    | Tokenizer_state.Comment_end -> state_comment_end ()
+    | Tokenizer_state.Comment_end_bang -> state_comment_end_bang ()
+    | Tokenizer_state.Doctype -> state_doctype ()
+    | Tokenizer_state.Before_doctype_name -> state_before_doctype_name ()
+    | Tokenizer_state.Doctype_name -> state_doctype_name ()
+    | Tokenizer_state.After_doctype_name -> state_after_doctype_name ()
+    | Tokenizer_state.After_doctype_public_keyword -> state_after_doctype_public_keyword ()
+    | Tokenizer_state.Before_doctype_public_identifier -> state_before_doctype_public_identifier ()
+    | Tokenizer_state.Doctype_public_identifier_double_quoted -> state_doctype_public_identifier_double_quoted ()
+    | Tokenizer_state.Doctype_public_identifier_single_quoted -> state_doctype_public_identifier_single_quoted ()
+    | Tokenizer_state.After_doctype_public_identifier -> state_after_doctype_public_identifier ()
+    | Tokenizer_state.Between_doctype_public_and_system_identifiers -> state_between_doctype_public_and_system_identifiers ()
+    | Tokenizer_state.After_doctype_system_keyword -> state_after_doctype_system_keyword ()
+    | Tokenizer_state.Before_doctype_system_identifier -> state_before_doctype_system_identifier ()
+    | Tokenizer_state.Doctype_system_identifier_double_quoted -> state_doctype_system_identifier_double_quoted ()
+    | Tokenizer_state.Doctype_system_identifier_single_quoted -> state_doctype_system_identifier_single_quoted ()
+    | Tokenizer_state.After_doctype_system_identifier -> state_after_doctype_system_identifier ()
+    | Tokenizer_state.Bogus_doctype -> state_bogus_doctype ()
+    | Tokenizer_state.Cdata_section -> state_cdata_section ()
+    | Tokenizer_state.Cdata_section_bracket -> state_cdata_section_bracket ()
+    | Tokenizer_state.Cdata_section_end -> state_cdata_section_end ()
+    | Tokenizer_state.Character_reference -> state_character_reference ()
+    | Tokenizer_state.Named_character_reference -> state_named_character_reference ()
+    | Tokenizer_state.Ambiguous_ampersand -> state_ambiguous_ampersand ()
+    | Tokenizer_state.Numeric_character_reference -> state_numeric_character_reference ()
+    | Tokenizer_state.Hexadecimal_character_reference_start -> state_hexadecimal_character_reference_start ()
+    | Tokenizer_state.Decimal_character_reference_start -> state_decimal_character_reference_start ()
+    | Tokenizer_state.Hexadecimal_character_reference -> state_hexadecimal_character_reference ()
+    | Tokenizer_state.Decimal_character_reference -> state_decimal_character_reference ()
+    | Tokenizer_state.Numeric_character_reference_end -> state_numeric_character_reference_end ()
+
+  (* State implementations *)
+  and state_data () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '&' ->
+      t.return_state <- Tokenizer_state.Data;
+      t.state <- Tokenizer_state.Character_reference
+    | Some '<' ->
+      t.state <- Tokenizer_state.Tag_open
+    | Some '\x00' ->
+      (* Emit pending chars first, then emit null separately for proper tree builder handling *)
+      emit_pending_chars ();
+      error t "unexpected-null-character";
+      ignore (S.process t.sink (Tokenizer_token.Character "\x00"))
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_rcdata () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '&' ->
+      t.return_state <- Tokenizer_state.Rcdata;
+      t.state <- Tokenizer_state.Character_reference
+    | Some '<' ->
+      t.state <- Tokenizer_state.Rcdata_less_than_sign
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_rawtext () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '<' ->
+      t.state <- Tokenizer_state.Rawtext_less_than_sign
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_less_than_sign
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_plaintext () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_tag_open () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '!' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Markup_declaration_open
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.End_tag_open
+    | Some c when is_ascii_alpha c ->
+      start_new_tag t Tokenizer_token.Start;
+      t.state <- Tokenizer_state.Tag_name
+    | Some '?' ->
+      error t "unexpected-question-mark-instead-of-tag-name";
+      Buffer.clear t.current_comment;
+      t.state <- Tokenizer_state.Bogus_comment
+    | None ->
+      error t "eof-before-tag-name";
+      emit_char t '<'
+    | Some _ ->
+      error t "invalid-first-character-of-tag-name";
+      emit_char t '<';
+      t.state <- Tokenizer_state.Data
+
+  and state_end_tag_open () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alpha c ->
+      start_new_tag t Tokenizer_token.End;
+      t.state <- Tokenizer_state.Tag_name
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-end-tag-name";
+      t.state <- Tokenizer_state.Data
+    | None ->
+      error t "eof-before-tag-name";
+      emit_str t "</"
+    | Some _ ->
+      error t "invalid-first-character-of-tag-name";
+      Buffer.clear t.current_comment;
+      t.state <- Tokenizer_state.Bogus_comment
+
+  and state_tag_name () =
+    match Tokenizer_stream.consume t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '/' ->
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '>' ->
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_tag_name "\xEF\xBF\xBD"
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char t.current_tag_name (ascii_lower c)
+    | None -> ()
+
+  and state_rcdata_less_than_sign () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.clear t.temp_buffer;
+      t.state <- Tokenizer_state.Rcdata_end_tag_open
+    | _ ->
+      emit_char t '<';
+      t.state <- Tokenizer_state.Rcdata
+
+  and state_rcdata_end_tag_open () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alpha c ->
+      start_new_tag t Tokenizer_token.End;
+      t.state <- Tokenizer_state.Rcdata_end_tag_name
+    | _ ->
+      emit_str t "</";
+      t.state <- Tokenizer_state.Rcdata
+
+  and state_rcdata_end_tag_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '/' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '>' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | Some c when is_ascii_alpha c ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_tag_name (ascii_lower c);
+      Buffer.add_char t.temp_buffer c
+    | _ ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      t.state <- Tokenizer_state.Rcdata
+
+  and state_rawtext_less_than_sign () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.clear t.temp_buffer;
+      t.state <- Tokenizer_state.Rawtext_end_tag_open
+    | _ ->
+      emit_char t '<';
+      t.state <- Tokenizer_state.Rawtext
+
+  and state_rawtext_end_tag_open () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alpha c ->
+      start_new_tag t Tokenizer_token.End;
+      t.state <- Tokenizer_state.Rawtext_end_tag_name
+    | _ ->
+      emit_str t "</";
+      t.state <- Tokenizer_state.Rawtext
+
+  and state_rawtext_end_tag_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '/' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '>' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | Some c when is_ascii_alpha c ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_tag_name (ascii_lower c);
+      Buffer.add_char t.temp_buffer c
+    | _ ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      t.state <- Tokenizer_state.Rawtext
+
+  and state_script_data_less_than_sign () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.clear t.temp_buffer;
+      t.state <- Tokenizer_state.Script_data_end_tag_open
+    | Some '!' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Script_data_escape_start;
+      emit_str t "<!"
+    | _ ->
+      emit_char t '<';
+      t.state <- Tokenizer_state.Script_data
+
+  and state_script_data_end_tag_open () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alpha c ->
+      start_new_tag t Tokenizer_token.End;
+      t.state <- Tokenizer_state.Script_data_end_tag_name
+    | _ ->
+      emit_str t "</";
+      t.state <- Tokenizer_state.Script_data
+
+  and state_script_data_end_tag_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '/' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '>' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | Some c when is_ascii_alpha c ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_tag_name (ascii_lower c);
+      Buffer.add_char t.temp_buffer c
+    | _ ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      t.state <- Tokenizer_state.Script_data
+
+  and state_script_data_escape_start () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Script_data_escape_start_dash;
+      emit_char t '-'
+    | _ ->
+      t.state <- Tokenizer_state.Script_data
+
+  and state_script_data_escape_start_dash () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Script_data_escaped_dash_dash;
+      emit_char t '-'
+    | _ ->
+      t.state <- Tokenizer_state.Script_data
+
+  and state_script_data_escaped () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '-' ->
+      t.state <- Tokenizer_state.Script_data_escaped_dash;
+      emit_char t '-'
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_escaped_less_than_sign
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data_escaped_dash () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '-' ->
+      t.state <- Tokenizer_state.Script_data_escaped_dash_dash;
+      emit_char t '-'
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_escaped_less_than_sign
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      t.state <- Tokenizer_state.Script_data_escaped;
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      t.state <- Tokenizer_state.Script_data_escaped;
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data_escaped_dash_dash () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '-' ->
+      emit_char t '-'
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_escaped_less_than_sign
+    | Some '>' ->
+      t.state <- Tokenizer_state.Script_data;
+      emit_char t '>'
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      t.state <- Tokenizer_state.Script_data_escaped;
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      t.state <- Tokenizer_state.Script_data_escaped;
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data_escaped_less_than_sign () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.clear t.temp_buffer;
+      t.state <- Tokenizer_state.Script_data_escaped_end_tag_open
+    | Some c when is_ascii_alpha c ->
+      Buffer.clear t.temp_buffer;
+      emit_char t '<';
+      t.state <- Tokenizer_state.Script_data_double_escape_start
+    | _ ->
+      emit_char t '<';
+      t.state <- Tokenizer_state.Script_data_escaped
+
+  and state_script_data_escaped_end_tag_open () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alpha c ->
+      start_new_tag t Tokenizer_token.End;
+      t.state <- Tokenizer_state.Script_data_escaped_end_tag_name
+    | _ ->
+      emit_str t "</";
+      t.state <- Tokenizer_state.Script_data_escaped
+
+  and state_script_data_escaped_end_tag_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '/' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '>' when is_appropriate_end_tag t ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | Some c when is_ascii_alpha c ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_tag_name (ascii_lower c);
+      Buffer.add_char t.temp_buffer c
+    | _ ->
+      emit_str t "</";
+      emit_str t (Buffer.contents t.temp_buffer);
+      t.state <- Tokenizer_state.Script_data_escaped
+
+  and state_script_data_double_escape_start () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ' | '/' | '>') as c_opt ->
+      Tokenizer_stream.advance t.stream;
+      let c = Option.get c_opt in
+      if Buffer.contents t.temp_buffer = "script" then
+        t.state <- Tokenizer_state.Script_data_double_escaped
+      else
+        t.state <- Tokenizer_state.Script_data_escaped;
+      emit_char t c
+    | Some c when is_ascii_alpha c ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.temp_buffer (ascii_lower c);
+      emit_char t c
+    | _ ->
+      t.state <- Tokenizer_state.Script_data_escaped
+
+  and state_script_data_double_escaped () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '-' ->
+      t.state <- Tokenizer_state.Script_data_double_escaped_dash;
+      emit_char t '-'
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_double_escaped_less_than_sign;
+      emit_char t '<'
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data_double_escaped_dash () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '-' ->
+      t.state <- Tokenizer_state.Script_data_double_escaped_dash_dash;
+      emit_char t '-'
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_double_escaped_less_than_sign;
+      emit_char t '<'
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      t.state <- Tokenizer_state.Script_data_double_escaped;
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      t.state <- Tokenizer_state.Script_data_double_escaped;
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data_double_escaped_dash_dash () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '-' ->
+      emit_char t '-'
+    | Some '<' ->
+      t.state <- Tokenizer_state.Script_data_double_escaped_less_than_sign;
+      emit_char t '<'
+    | Some '>' ->
+      t.state <- Tokenizer_state.Script_data;
+      emit_char t '>'
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      t.state <- Tokenizer_state.Script_data_double_escaped;
+      emit_str t "\xEF\xBF\xBD"
+    | Some c ->
+      t.state <- Tokenizer_state.Script_data_double_escaped;
+      emit_char_checked c
+    | None -> ()
+
+  and state_script_data_double_escaped_less_than_sign () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.clear t.temp_buffer;
+      t.state <- Tokenizer_state.Script_data_double_escape_end;
+      emit_char t '/'
+    | _ ->
+      t.state <- Tokenizer_state.Script_data_double_escaped
+
+  and state_script_data_double_escape_end () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ' | '/' | '>') as c_opt ->
+      Tokenizer_stream.advance t.stream;
+      let c = Option.get c_opt in
+      if Buffer.contents t.temp_buffer = "script" then
+        t.state <- Tokenizer_state.Script_data_escaped
+      else
+        t.state <- Tokenizer_state.Script_data_double_escaped;
+      emit_char t c
+    | Some c when is_ascii_alpha c ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.temp_buffer (ascii_lower c);
+      emit_char t c
+    | _ ->
+      t.state <- Tokenizer_state.Script_data_double_escaped
+
+  and state_before_attribute_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '/' | Some '>' | None ->
+      t.state <- Tokenizer_state.After_attribute_name
+    | Some '=' ->
+      Tokenizer_stream.advance t.stream;
+      error t "unexpected-equals-sign-before-attribute-name";
+      start_new_attribute t;
+      Buffer.add_char t.current_attr_name '=';
+      t.state <- Tokenizer_state.Attribute_name
+    | Some _ ->
+      start_new_attribute t;
+      t.state <- Tokenizer_state.Attribute_name
+
+  and state_attribute_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.After_attribute_name
+    | Some '/' | Some '>' | None ->
+      t.state <- Tokenizer_state.After_attribute_name
+    | Some '=' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_value
+    | Some '\x00' ->
+      Tokenizer_stream.advance t.stream;
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_attr_name "\xEF\xBF\xBD"
+    | Some ('"' | '\'' | '<') as c_opt ->
+      Tokenizer_stream.advance t.stream;
+      error t "unexpected-character-in-attribute-name";
+      Buffer.add_char t.current_attr_name (Option.get c_opt)
+    | Some c ->
+      Tokenizer_stream.advance t.stream;
+      check_control_char c;
+      Buffer.add_char t.current_attr_name (ascii_lower c)
+
+  and state_after_attribute_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '=' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_value
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | None -> ()
+    | Some _ ->
+      start_new_attribute t;
+      t.state <- Tokenizer_state.Attribute_name
+
+  and state_before_attribute_value () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Attribute_value_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Attribute_value_single_quoted
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-attribute-value";
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | _ ->
+      t.state <- Tokenizer_state.Attribute_value_unquoted
+
+  and state_attribute_value_double_quoted () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '"' ->
+      t.state <- Tokenizer_state.After_attribute_value_quoted
+    | Some '&' ->
+      t.return_state <- Tokenizer_state.Attribute_value_double_quoted;
+      t.state <- Tokenizer_state.Character_reference
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_attr_value "\xEF\xBF\xBD"
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char t.current_attr_value c
+    | None -> ()
+
+  and state_attribute_value_single_quoted () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '\'' ->
+      t.state <- Tokenizer_state.After_attribute_value_quoted
+    | Some '&' ->
+      t.return_state <- Tokenizer_state.Attribute_value_single_quoted;
+      t.state <- Tokenizer_state.Character_reference
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_attr_value "\xEF\xBF\xBD"
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char t.current_attr_value c
+    | None -> ()
+
+  and state_attribute_value_unquoted () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '&' ->
+      Tokenizer_stream.advance t.stream;
+      t.return_state <- Tokenizer_state.Attribute_value_unquoted;
+      t.state <- Tokenizer_state.Character_reference
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | Some '\x00' ->
+      Tokenizer_stream.advance t.stream;
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_attr_value "\xEF\xBF\xBD"
+    | Some ('"' | '\'' | '<' | '=' | '`') as c_opt ->
+      Tokenizer_stream.advance t.stream;
+      error t "unexpected-character-in-unquoted-attribute-value";
+      Buffer.add_char t.current_attr_value (Option.get c_opt)
+    | Some c ->
+      Tokenizer_stream.advance t.stream;
+      check_control_char c;
+      Buffer.add_char t.current_attr_value c
+    | None -> ()
+
+  and state_after_attribute_value_quoted () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_attribute_name
+    | Some '/' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Self_closing_start_tag
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | None -> ()
+    | Some _ ->
+      error t "missing-whitespace-between-attributes";
+      t.state <- Tokenizer_state.Before_attribute_name
+
+  and state_self_closing_start_tag () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_tag_self_closing <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_tag ()
+    | None -> ()
+    | Some _ ->
+      error t "unexpected-solidus-in-tag";
+      t.state <- Tokenizer_state.Before_attribute_name
+
+  and state_bogus_comment () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '>' ->
+      t.state <- Tokenizer_state.Data;
+      emit_current_comment ()
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_comment "\xEF\xBF\xBD"
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char t.current_comment c
+    | None -> ()
+
+  and state_markup_declaration_open () =
+    if Tokenizer_stream.matches_ci t.stream "--" then begin
+      ignore (Tokenizer_stream.consume_exact_ci t.stream "--");
+      Buffer.clear t.current_comment;
+      t.state <- Tokenizer_state.Comment_start
+    end else if Tokenizer_stream.matches_ci t.stream "DOCTYPE" then begin
+      ignore (Tokenizer_stream.consume_exact_ci t.stream "DOCTYPE");
+      t.state <- Tokenizer_state.Doctype
+    end else if Tokenizer_stream.matches_ci t.stream "[CDATA[" then begin
+      ignore (Tokenizer_stream.consume_exact_ci t.stream "[CDATA[");
+      (* CDATA only allowed in foreign content *)
+      if S.adjusted_current_node_in_html_namespace t.sink then begin
+        error t "cdata-in-html-content";
+        Buffer.clear t.current_comment;
+        Buffer.add_string t.current_comment "[CDATA[";
+        t.state <- Tokenizer_state.Bogus_comment
+      end else
+        t.state <- Tokenizer_state.Cdata_section
+    end else begin
+      error t "incorrectly-opened-comment";
+      Buffer.clear t.current_comment;
+      t.state <- Tokenizer_state.Bogus_comment
+    end
+
+  and state_comment_start () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Comment_start_dash
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "abrupt-closing-of-empty-comment";
+      t.state <- Tokenizer_state.Data;
+      emit_current_comment ()
+    | _ ->
+      t.state <- Tokenizer_state.Comment
+
+  and state_comment_start_dash () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Comment_end
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "abrupt-closing-of-empty-comment";
+      t.state <- Tokenizer_state.Data;
+      emit_current_comment ()
+    | None -> ()
+    | Some _ ->
+      Buffer.add_char t.current_comment '-';
+      t.state <- Tokenizer_state.Comment
+
+  and state_comment () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '<' ->
+      Buffer.add_char t.current_comment '<';
+      t.state <- Tokenizer_state.Comment_less_than_sign
+    | Some '-' ->
+      t.state <- Tokenizer_state.Comment_end_dash
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string t.current_comment "\xEF\xBF\xBD"
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char t.current_comment c
+    | None -> ()
+
+  and state_comment_less_than_sign () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '!' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_comment '!';
+      t.state <- Tokenizer_state.Comment_less_than_sign_bang
+    | Some '<' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_comment '<'
+    | _ ->
+      t.state <- Tokenizer_state.Comment
+
+  and state_comment_less_than_sign_bang () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Comment_less_than_sign_bang_dash
+    | _ ->
+      t.state <- Tokenizer_state.Comment
+
+  and state_comment_less_than_sign_bang_dash () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Comment_less_than_sign_bang_dash_dash
+    | _ ->
+      t.state <- Tokenizer_state.Comment_end_dash
+
+  and state_comment_less_than_sign_bang_dash_dash () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '>' | None ->
+      t.state <- Tokenizer_state.Comment_end
+    | Some _ ->
+      error t "nested-comment";
+      t.state <- Tokenizer_state.Comment_end
+
+  and state_comment_end_dash () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Comment_end
+    | None -> ()
+    | Some _ ->
+      Buffer.add_char t.current_comment '-';
+      t.state <- Tokenizer_state.Comment
+
+  and state_comment_end () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_comment ()
+    | Some '!' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Comment_end_bang
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.current_comment '-'
+    | None -> ()
+    | Some _ ->
+      Buffer.add_string t.current_comment "--";
+      t.state <- Tokenizer_state.Comment
+
+  and state_comment_end_bang () =
+    match Tokenizer_stream.peek t.stream with
+    | Some '-' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_string t.current_comment "--!";
+      t.state <- Tokenizer_state.Comment_end_dash
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "incorrectly-closed-comment";
+      t.state <- Tokenizer_state.Data;
+      emit_current_comment ()
+    | None -> ()
+    | Some _ ->
+      Buffer.add_string t.current_comment "--!";
+      t.state <- Tokenizer_state.Comment
+
+  and state_doctype () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_doctype_name
+    | Some '>' ->
+      t.state <- Tokenizer_state.Before_doctype_name
+    | None -> ()
+    | Some _ ->
+      error t "missing-whitespace-before-doctype-name";
+      t.state <- Tokenizer_state.Before_doctype_name
+
+  and state_before_doctype_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '\x00' ->
+      Tokenizer_stream.advance t.stream;
+      error t "unexpected-null-character";
+      start_new_doctype t;
+      t.current_doctype_name <- Some (Buffer.create 8);
+      Buffer.add_string (Option.get t.current_doctype_name) "\xEF\xBF\xBD";
+      t.state <- Tokenizer_state.Doctype_name
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-doctype-name";
+      start_new_doctype t;
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some c ->
+      Tokenizer_stream.advance t.stream;
+      check_control_char c;
+      start_new_doctype t;
+      t.current_doctype_name <- Some (Buffer.create 8);
+      Buffer.add_char (Option.get t.current_doctype_name) (ascii_lower c);
+      t.state <- Tokenizer_state.Doctype_name
+
+  and state_doctype_name () =
+    match Tokenizer_stream.consume t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      t.state <- Tokenizer_state.After_doctype_name
+    | Some '>' ->
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string (Option.get t.current_doctype_name) "\xEF\xBF\xBD"
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char (Option.get t.current_doctype_name) (ascii_lower c)
+    | None -> ()
+
+  and state_after_doctype_name () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      if Tokenizer_stream.matches_ci t.stream "PUBLIC" then begin
+        ignore (Tokenizer_stream.consume_exact_ci t.stream "PUBLIC");
+        t.state <- Tokenizer_state.After_doctype_public_keyword
+      end else if Tokenizer_stream.matches_ci t.stream "SYSTEM" then begin
+        ignore (Tokenizer_stream.consume_exact_ci t.stream "SYSTEM");
+        t.state <- Tokenizer_state.After_doctype_system_keyword
+      end else begin
+        error t "invalid-character-sequence-after-doctype-name";
+        t.current_doctype_force_quirks <- true;
+        t.state <- Tokenizer_state.Bogus_doctype
+      end
+
+  and state_after_doctype_public_keyword () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_doctype_public_identifier
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-whitespace-after-doctype-public-keyword";
+      t.current_doctype_public <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_public_identifier_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-whitespace-after-doctype-public-keyword";
+      t.current_doctype_public <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_public_identifier_single_quoted
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-doctype-public-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      error t "missing-quote-before-doctype-public-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_before_doctype_public_identifier () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_doctype_public <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_public_identifier_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_doctype_public <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_public_identifier_single_quoted
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-doctype-public-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some _ ->
+      error t "missing-quote-before-doctype-public-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_doctype_public_identifier_double_quoted () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '"' ->
+      t.state <- Tokenizer_state.After_doctype_public_identifier
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string (Option.get t.current_doctype_public) "\xEF\xBF\xBD"
+    | Some '>' ->
+      error t "abrupt-doctype-public-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char (Option.get t.current_doctype_public) c
+    | None -> ()
+
+  and state_doctype_public_identifier_single_quoted () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '\'' ->
+      t.state <- Tokenizer_state.After_doctype_public_identifier
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string (Option.get t.current_doctype_public) "\xEF\xBF\xBD"
+    | Some '>' ->
+      error t "abrupt-doctype-public-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char (Option.get t.current_doctype_public) c
+    | None -> ()
+
+  and state_after_doctype_public_identifier () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Between_doctype_public_and_system_identifiers
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-whitespace-between-doctype-public-and-system-identifiers";
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-whitespace-between-doctype-public-and-system-identifiers";
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_single_quoted
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      error t "missing-quote-before-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_between_doctype_public_and_system_identifiers () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_single_quoted
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      error t "missing-quote-before-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_after_doctype_system_keyword () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Before_doctype_system_identifier
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-whitespace-after-doctype-system-keyword";
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-whitespace-after-doctype-system-keyword";
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_single_quoted
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      error t "missing-quote-before-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_before_doctype_system_identifier () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '"' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_double_quoted
+    | Some '\'' ->
+      Tokenizer_stream.advance t.stream;
+      t.current_doctype_system <- Some (Buffer.create 32);
+      t.state <- Tokenizer_state.Doctype_system_identifier_single_quoted
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      error t "missing-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      error t "missing-quote-before-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_doctype_system_identifier_double_quoted () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '"' ->
+      t.state <- Tokenizer_state.After_doctype_system_identifier
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string (Option.get t.current_doctype_system) "\xEF\xBF\xBD"
+    | Some '>' ->
+      error t "abrupt-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char (Option.get t.current_doctype_system) c
+    | None -> ()
+
+  and state_doctype_system_identifier_single_quoted () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '\'' ->
+      t.state <- Tokenizer_state.After_doctype_system_identifier
+    | Some '\x00' ->
+      error t "unexpected-null-character";
+      Buffer.add_string (Option.get t.current_doctype_system) "\xEF\xBF\xBD"
+    | Some '>' ->
+      error t "abrupt-doctype-system-identifier";
+      t.current_doctype_force_quirks <- true;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some c ->
+      check_control_char c;
+      Buffer.add_char (Option.get t.current_doctype_system) c
+    | None -> ()
+
+  and state_after_doctype_system_identifier () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ('\t' | '\n' | '\x0C' | ' ') ->
+      Tokenizer_stream.advance t.stream
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | None -> ()
+    | Some _ ->
+      (* Don't check control char here - bogus_doctype will check when it consumes *)
+      error t "unexpected-character-after-doctype-system-identifier";
+      t.state <- Tokenizer_state.Bogus_doctype
+
+  and state_bogus_doctype () =
+    match Tokenizer_stream.consume t.stream with
+    | Some '>' ->
+      t.state <- Tokenizer_state.Data;
+      emit_current_doctype ()
+    | Some '\x00' ->
+      error t "unexpected-null-character"
+    | Some c ->
+      check_control_char c  (* Check all chars in bogus doctype *)
+    | None -> ()
+
+  and state_cdata_section () =
+    match Tokenizer_stream.consume t.stream with
+    | Some ']' ->
+      t.state <- Tokenizer_state.Cdata_section_bracket
+    | Some c ->
+      (* CDATA section emits all characters as-is, including NUL, but still check for control chars *)
+      emit_char_checked c
+    | None -> ()
+
+  and state_cdata_section_bracket () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ']' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Cdata_section_end
+    | _ ->
+      emit_char t ']';
+      t.state <- Tokenizer_state.Cdata_section
+
+  and state_cdata_section_end () =
+    match Tokenizer_stream.peek t.stream with
+    | Some ']' ->
+      Tokenizer_stream.advance t.stream;
+      emit_char t ']'
+    | Some '>' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Data
+    | _ ->
+      emit_str t "]]";
+      t.state <- Tokenizer_state.Cdata_section
+
+  and state_character_reference () =
+    Buffer.clear t.temp_buffer;
+    Buffer.add_char t.temp_buffer '&';
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alnum c ->
+      t.state <- Tokenizer_state.Named_character_reference
+    | Some '#' ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.temp_buffer '#';
+      t.state <- Tokenizer_state.Numeric_character_reference
+    | _ ->
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state
+
+  and state_named_character_reference () =
+    (* Collect alphanumeric characters *)
+    let rec collect () =
+      match Tokenizer_stream.peek t.stream with
+      | Some c when is_ascii_alnum c ->
+        Tokenizer_stream.advance t.stream;
+        Buffer.add_char t.temp_buffer c;
+        collect ()
+      | _ -> ()
+    in
+    collect ();
+
+    let has_semicolon =
+      match Tokenizer_stream.peek t.stream with
+      | Some ';' -> Tokenizer_stream.advance t.stream; Buffer.add_char t.temp_buffer ';'; true
+      | _ -> false
+    in
+
+    (* Try to match entity - buffer contains "&name" or "&name;" *)
+    let buf_contents = Buffer.contents t.temp_buffer in
+    let name_start = 1 in (* Skip '&' *)
+    let name_end = String.length buf_contents - (if has_semicolon then 1 else 0) in
+    let entity_name = String.sub buf_contents name_start (name_end - name_start) in
+
+    (* Try progressively shorter matches *)
+    (* Only match if:
+       1. Full match with semicolon, OR
+       2. Legacy entity (can be used without semicolon) *)
+    let rec try_match len =
+      if len <= 0 then None
+      else
+        let prefix = String.sub entity_name 0 len in
+        let is_full = len = String.length entity_name in
+        let would_have_semi = has_semicolon && is_full in
+        (* Only use this match if it has semicolon or is a legacy entity *)
+        if would_have_semi || Entities.is_legacy prefix then
+          match Entities.lookup prefix with
+          | Some decoded -> Some (decoded, len)
+          | None -> try_match (len - 1)
+        else
+          try_match (len - 1)
+    in
+
+    match try_match (String.length entity_name) with
+    | Some (decoded, matched_len) ->
+      let full_match = matched_len = String.length entity_name in
+      let ends_with_semi = has_semicolon && full_match in
+
+      (* Check attribute context restrictions *)
+      let in_attribute = match t.return_state with
+        | Tokenizer_state.Attribute_value_double_quoted
+        | Tokenizer_state.Attribute_value_single_quoted
+        | Tokenizer_state.Attribute_value_unquoted -> true
+        | _ -> false
+      in
+
+      let next_char =
+        if full_match && not has_semicolon then
+          Tokenizer_stream.peek t.stream
+        else if not full_match then
+          Some entity_name.[matched_len]
+        else None
+      in
+
+      let blocked = in_attribute && not ends_with_semi &&
+        match next_char with
+        | Some '=' -> true
+        | Some c when is_ascii_alnum c -> true
+        | _ -> false
+      in
+
+      if blocked then begin
+        flush_code_points_consumed_as_char_ref t;
+        t.state <- t.return_state
+      end else begin
+        if not ends_with_semi then
+          error t "missing-semicolon-after-character-reference";
+        Buffer.clear t.temp_buffer;
+        Buffer.add_string t.temp_buffer decoded;
+        flush_code_points_consumed_as_char_ref t;
+        (* Emit unconsumed chars after partial match *)
+        if not full_match then begin
+          let unconsumed = String.sub entity_name matched_len (String.length entity_name - matched_len) in
+          emit_str t unconsumed;
+          (* If there was a semicolon in input but we didn't use the full match, emit the semicolon too *)
+          if has_semicolon then
+            emit_char t ';'
+        end;
+        t.state <- t.return_state
+      end
+    | None ->
+      (* No match - check if we should report unknown-named-character-reference *)
+      if String.length entity_name > 0 then begin
+        (* If we have a semicolon, it's definitely an unknown named character reference *)
+        if has_semicolon then
+          error t "unknown-named-character-reference";
+        (* Emit all the chars we consumed *)
+        flush_code_points_consumed_as_char_ref t;
+        t.state <- t.return_state
+      end else begin
+        flush_code_points_consumed_as_char_ref t;
+        t.state <- t.return_state
+      end
+
+  and state_ambiguous_ampersand () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_alnum c ->
+      Tokenizer_stream.advance t.stream;
+      (match t.return_state with
+      | Tokenizer_state.Attribute_value_double_quoted
+      | Tokenizer_state.Attribute_value_single_quoted
+      | Tokenizer_state.Attribute_value_unquoted ->
+        Buffer.add_char t.current_attr_value c
+      | _ ->
+        emit_char t c)
+    | Some ';' ->
+      error t "unknown-named-character-reference";
+      t.state <- t.return_state
+    | _ ->
+      t.state <- t.return_state
+
+  and state_numeric_character_reference () =
+    t.char_ref_code <- 0;
+    match Tokenizer_stream.peek t.stream with
+    | Some (('x' | 'X') as c) ->
+      Tokenizer_stream.advance t.stream;
+      Buffer.add_char t.temp_buffer c;
+      t.state <- Tokenizer_state.Hexadecimal_character_reference_start
+    | _ ->
+      t.state <- Tokenizer_state.Decimal_character_reference_start
+
+  and state_hexadecimal_character_reference_start () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_hex c ->
+      t.state <- Tokenizer_state.Hexadecimal_character_reference
+    | _ ->
+      error t "absence-of-digits-in-numeric-character-reference";
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state
+
+  and state_decimal_character_reference_start () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_digit c ->
+      t.state <- Tokenizer_state.Decimal_character_reference
+    | _ ->
+      error t "absence-of-digits-in-numeric-character-reference";
+      flush_code_points_consumed_as_char_ref t;
+      t.state <- t.return_state
+
+  and state_hexadecimal_character_reference () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_digit c ->
+      Tokenizer_stream.advance t.stream;
+      t.char_ref_code <- t.char_ref_code * 16 + (Char.code c - Char.code '0');
+      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
+    | Some c when c >= 'A' && c <= 'F' ->
+      Tokenizer_stream.advance t.stream;
+      t.char_ref_code <- t.char_ref_code * 16 + (Char.code c - Char.code 'A' + 10);
+      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
+    | Some c when c >= 'a' && c <= 'f' ->
+      Tokenizer_stream.advance t.stream;
+      t.char_ref_code <- t.char_ref_code * 16 + (Char.code c - Char.code 'a' + 10);
+      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
+    | Some ';' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Numeric_character_reference_end
+    | _ ->
+      error t "missing-semicolon-after-character-reference";
+      t.state <- Tokenizer_state.Numeric_character_reference_end
+
+  and state_decimal_character_reference () =
+    match Tokenizer_stream.peek t.stream with
+    | Some c when is_ascii_digit c ->
+      Tokenizer_stream.advance t.stream;
+      t.char_ref_code <- t.char_ref_code * 10 + (Char.code c - Char.code '0');
+      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
+    | Some ';' ->
+      Tokenizer_stream.advance t.stream;
+      t.state <- Tokenizer_state.Numeric_character_reference_end
+    | _ ->
+      error t "missing-semicolon-after-character-reference";
+      t.state <- Tokenizer_state.Numeric_character_reference_end
+
+  and state_numeric_character_reference_end () =
+    let code = t.char_ref_code in
+    let replacement_char = "\xEF\xBF\xBD" in
+
+    let result =
+      if code = 0 then begin
+        error t "null-character-reference";
+        replacement_char
+      end else if code > 0x10FFFF then begin
+        error t "character-reference-outside-unicode-range";
+        replacement_char
+      end else if code >= 0xD800 && code <= 0xDFFF then begin
+        error t "surrogate-character-reference";
+        replacement_char
+      end else if (code >= 0xFDD0 && code <= 0xFDEF) ||
+                  List.mem code [0xFFFE; 0xFFFF; 0x1FFFE; 0x1FFFF; 0x2FFFE; 0x2FFFF;
+                                 0x3FFFE; 0x3FFFF; 0x4FFFE; 0x4FFFF; 0x5FFFE; 0x5FFFF;
+                                 0x6FFFE; 0x6FFFF; 0x7FFFE; 0x7FFFF; 0x8FFFE; 0x8FFFF;
+                                 0x9FFFE; 0x9FFFF; 0xAFFFE; 0xAFFFF; 0xBFFFE; 0xBFFFF;
+                                 0xCFFFE; 0xCFFFF; 0xDFFFE; 0xDFFFF; 0xEFFFE; 0xEFFFF;
+                                 0xFFFFE; 0xFFFFF; 0x10FFFE; 0x10FFFF] then begin
+        error t "noncharacter-character-reference";
+        Entities.Numeric_ref.codepoint_to_utf8 code
+      end else if (code >= 0x01 && code <= 0x08) || code = 0x0B ||
+                  (code >= 0x0D && code <= 0x1F) ||
+                  (code >= 0x7F && code <= 0x9F) then begin
+        error t "control-character-reference";
+        (* Apply Windows-1252 replacement table for 0x80-0x9F *)
+        match Entities.Numeric_ref.find_replacement code with
+        | Some replacement -> Entities.Numeric_ref.codepoint_to_utf8 replacement
+        | None -> Entities.Numeric_ref.codepoint_to_utf8 code
+      end else
+        Entities.Numeric_ref.codepoint_to_utf8 code
+    in
+
+    Buffer.clear t.temp_buffer;
+    Buffer.add_string t.temp_buffer result;
+    flush_code_points_consumed_as_char_ref t;
+    t.state <- t.return_state
+
+  in
+  process_state ()
+
+let get_errors t = List.rev t.errors
+
+let set_state t state = t.state <- state
+
+let set_last_start_tag t name = t.last_start_tag <- name

lib/parser/dune

···
-(library
- (name html5rw_parser)
- (public_name html5rw.parser)
- (libraries astring bytesrw html5rw.tokenizer html5rw.dom html5rw.encoding html5rw.selector))

lib/parser/html5rw_parser.ml

···
-(*---------------------------------------------------------------------------
-  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
-  SPDX-License-Identifier: MIT
- ---------------------------------------------------------------------------*)
-
-(* html5rw.parser - HTML5 parser with bytesrw-only API *)
-
-module Dom = Html5rw_dom
-module Tokenizer = Html5rw_tokenizer
-module Encoding = Html5rw_encoding
-module Constants = Constants
-module Insertion_mode = Insertion_mode
-module Tree_builder = Tree_builder
-
-type parse_error = Parser.parse_error
-type fragment_context = Parser.fragment_context
-type t = Parser.t
-
-(* parse_error accessors *)
-let error_code (e : parse_error) = e.Tree_builder.code
-let error_line (e : parse_error) = e.Tree_builder.line
-let error_column (e : parse_error) = e.Tree_builder.column
-
-(* fragment_context constructor and accessors *)
-let make_fragment_context ~tag_name ?(namespace=None) () : fragment_context =
-  { Tree_builder.tag_name; namespace }
-
-let fragment_context_tag (ctx : fragment_context) = ctx.Tree_builder.tag_name
-let fragment_context_namespace (ctx : fragment_context) = ctx.Tree_builder.namespace
-
-let parse = Parser.parse
-let parse_bytes = Parser.parse_bytes
-let query = Parser.query
-let to_writer = Parser.to_writer
-let to_string = Parser.to_string
-let to_text = Parser.to_text
-let to_test_format = Parser.to_test_format
-
-let root t = t.Parser.root
-let errors t = t.Parser.errors
-let encoding t = t.Parser.encoding

lib/parser/html5rw_parser.mli lib/html5rw/parser/parser.mli

···
 (** {1 Sub-modules} *)
 
 (** DOM types and manipulation. *)
-module Dom = Html5rw_dom
+module Dom = Dom
 
 (** HTML5 tokenizer.
 
···
 
     @see <https://html.spec.whatwg.org/multipage/parsing.html#tokenization>
          WHATWG: Tokenization *)
-module Tokenizer = Html5rw_tokenizer
+module Tokenizer = Tokenizer
 
 (** Character encoding detection and conversion.
 
     @see <https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding>
          WHATWG: Determining the character encoding *)
-module Encoding = Html5rw_encoding
+module Encoding = Encoding
 
 (** HTML element constants and categories.
 
···
 
     {b Supported selectors:}
 
-    See {!Html5rw_selector} for the complete list. Key selectors include:
+    See {!Selector} for the complete list. Key selectors include:
     - Type: [div], [p], [a]
     - ID: [#myid]
     - Class: [.myclass]
···
     - Pseudo-class: [:first-child], [:nth-child(2)]
     - Combinators: [div p] (descendant), [div > p] (child)
 
-    @raise Html5rw_selector.Selector_error if the selector is invalid
+    @raise Selector.Selector_error if the selector is invalid
 
     @see <https://www.w3.org/TR/selectors-4/>
          W3C: Selectors Level 4 *)

lib/parser/parser.ml lib/html5rw/parser/parser_impl.ml

···
 
 open Bytesrw
 
-module Dom = Html5rw_dom
-module Tokenizer = Html5rw_tokenizer
-module Encoding = Html5rw_encoding
+module Dom = Dom
+module Tokenizer = Tokenizer
+module Encoding = Encoding
 
-type parse_error = Tree_builder.parse_error
+type parse_error = Parser_tree_builder.parse_error
 
-type fragment_context = Tree_builder.fragment_context
+type fragment_context = Parser_tree_builder.fragment_context
 
 type t = {
   root : Dom.node;
···
 
 (* Token sink that feeds tokens to tree builder *)
 module TreeBuilderSink = struct
-  type t = Tree_builder.t
+  type t = Parser_tree_builder.t
 
   let process tb token =
-    Tree_builder.process_token tb token;
+    Parser_tree_builder.process_token tb token;
     (* Check if we need to switch tokenizer state based on current element *)
     (* Only switch for HTML namespace elements - SVG/MathML use different rules *)
-    match Tree_builder.current_node tb with
+    match Parser_tree_builder.current_node tb with
     | Some node when node.Dom.namespace = None || node.Dom.namespace = Some "html" ->
       let name = node.Dom.name in
       if List.mem name ["textarea"; "title"] then
-        `SwitchTo Tokenizer.State.Rcdata
+        `SwitchTo Tokenizer_state.Rcdata
       else if List.mem name ["style"; "xmp"; "iframe"; "noembed"; "noframes"] then
-        `SwitchTo Tokenizer.State.Rawtext
+        `SwitchTo Tokenizer_state.Rawtext
       else if name = "script" then
-        `SwitchTo Tokenizer.State.Script_data
+        `SwitchTo Tokenizer_state.Script_data
       else if name = "plaintext" then
-        `SwitchTo Tokenizer.State.Plaintext
+        `SwitchTo Tokenizer_state.Plaintext
       else
         `Continue
     | _ -> `Continue
 
   let adjusted_current_node_in_html_namespace tb =
-    Tree_builder.adjusted_current_node_in_html_namespace tb
+    Parser_tree_builder.adjusted_current_node_in_html_namespace tb
 end
 
 (* Core parsing function that takes a Bytes.Reader.t *)
 let parse ?(collect_errors=false) ?fragment_context (reader : Bytes.Reader.t) =
-  let tb = Tree_builder.create ~collect_errors ?fragment_context () in
+  let tb = Parser_tree_builder.create ~collect_errors ?fragment_context () in
   let tokenizer = Tokenizer.create (module TreeBuilderSink) tb ~collect_errors () in
 
   (* Set tokenizer state for fragment parsing *)
···
    | Some ctx when ctx.namespace = None || ctx.namespace = Some "html" ->
      let name = String.lowercase_ascii ctx.tag_name in
      if List.mem name ["title"; "textarea"] then
-       Tokenizer.set_state tokenizer Tokenizer.State.Rcdata
+       Tokenizer.set_state tokenizer Tokenizer_state.Rcdata
      else if List.mem name ["style"; "xmp"; "iframe"; "noembed"; "noframes"] then
-       Tokenizer.set_state tokenizer Tokenizer.State.Rawtext
+       Tokenizer.set_state tokenizer Tokenizer_state.Rawtext
      else if name = "script" then
-       Tokenizer.set_state tokenizer Tokenizer.State.Script_data
+       Tokenizer.set_state tokenizer Tokenizer_state.Script_data
      else if name = "plaintext" then
-       Tokenizer.set_state tokenizer Tokenizer.State.Plaintext
+       Tokenizer.set_state tokenizer Tokenizer_state.Plaintext
    | _ -> ());
 
   Tokenizer.run tokenizer (module TreeBuilderSink) reader;
 
-  let root = Tree_builder.finish tb in
+  let root = Parser_tree_builder.finish tb in
   let tokenizer_errors = Tokenizer.get_errors tokenizer in
-  let tree_errors = Tree_builder.get_errors tb in
+  let tree_errors = Parser_tree_builder.get_errors tb in
   let all_errors = List.map (fun e ->
-    { Tree_builder.code = e.Tokenizer.Errors.code;
+    { Parser_tree_builder.code = e.Tokenizer.Errors.code;
       line = e.Tokenizer.Errors.line;
       column = e.Tokenizer.Errors.column }
   ) tokenizer_errors @ tree_errors in
···
   { result with encoding = Some enc }
 
 let query t selector =
-  Html5rw_selector.query t.root selector
+  Selector.query t.root selector
 
 (* Serialize to a Bytes.Writer.t *)
 let to_writer ?(pretty=true) ?(indent_size=2) t (writer : Bytes.Writer.t) =

lib/parser/tree_builder.ml lib/html5rw/parser/parser_tree_builder.ml

···
 (* HTML5 Tree Builder *)
 
-module Dom = Html5rw_dom
-module Token = Html5rw_tokenizer.Token
-module State = Html5rw_tokenizer.State
+module Dom = Dom
+module Token = Tokenizer_token
+module State = Tokenizer_state
 
 type fragment_context = {
   tag_name : string;
···
 
 type t = {
   mutable document : Dom.node;
-  mutable mode : Insertion_mode.t;
-  mutable original_mode : Insertion_mode.t option;
+  mutable mode : Parser_insertion_mode.t;
+  mutable original_mode : Parser_insertion_mode.t option;
   mutable open_elements : Dom.node list;
   mutable active_formatting : formatting_entry list;
   mutable head_element : Dom.node option;
···
   mutable ignore_lf : bool;
   mutable foster_parenting : bool;
   mutable pending_table_chars : string list;
-  mutable template_modes : Insertion_mode.t list;
+  mutable template_modes : Parser_insertion_mode.t list;
   mutable quirks_mode : Dom.quirks_mode;
   mutable errors : parse_error list;
   collect_errors : bool;
···
   let doc = if is_fragment then Dom.create_document_fragment () else Dom.create_document () in
   let t = {
     document = doc;
-    mode = Insertion_mode.Initial;
+    mode = Parser_insertion_mode.Initial;
     original_mode = None;
     open_elements = [];
     active_formatting = [];
···
     | _ -> ());
     (* Set initial mode based on context *)
     t.mode <- (
-      if name = "html" then Insertion_mode.Before_head
+      if name = "html" then Parser_insertion_mode.Before_head
       else if List.mem name ["tbody"; "thead"; "tfoot"] && (ns = None || ns = Some "html") then
-        Insertion_mode.In_table_body
+        Parser_insertion_mode.In_table_body
       else if name = "tr" && (ns = None || ns = Some "html") then
-        Insertion_mode.In_row
+        Parser_insertion_mode.In_row
       else if List.mem name ["td"; "th"] && (ns = None || ns = Some "html") then
-        Insertion_mode.In_cell
+        Parser_insertion_mode.In_cell
       else if name = "caption" && (ns = None || ns = Some "html") then
-        Insertion_mode.In_caption
+        Parser_insertion_mode.In_caption
       else if name = "colgroup" && (ns = None || ns = Some "html") then
-        Insertion_mode.In_column_group
+        Parser_insertion_mode.In_column_group
       else if name = "table" && (ns = None || ns = Some "html") then
-        Insertion_mode.In_table
+        Parser_insertion_mode.In_table
       else if name = "template" && (ns = None || ns = Some "html") then begin
-        t.template_modes <- [Insertion_mode.In_template];
-        Insertion_mode.In_template
+        t.template_modes <- [Parser_insertion_mode.In_template];
+        Parser_insertion_mode.In_template
       end
       else
-        Insertion_mode.In_body
+        Parser_insertion_mode.In_body
     );
     t.frameset_ok <- false
   | None -> ());
···
 let is_special_element node =
   let name = String.lowercase_ascii node.Dom.name in
   match node.Dom.namespace with
-  | None | Some "html" -> Constants.is_special name
+  | None | Some "html" -> Parser_constants.is_special name
   | Some "mathml" -> List.mem name ["mi"; "mo"; "mn"; "ms"; "mtext"; "annotation-xml"]
   | Some "svg" -> List.mem name ["foreignobject"; "desc"; "title"]
   | _ -> false
···
 let insert_foreign_element t (tag : Token.tag) namespace =
   let attrs =
     if namespace = Some "svg" then
-      Constants.adjust_svg_attrs (Constants.adjust_foreign_attrs tag.attrs)
+      Parser_constants.adjust_svg_attrs (Parser_constants.adjust_foreign_attrs tag.attrs)
     else
-      Constants.adjust_foreign_attrs tag.attrs
+      Parser_constants.adjust_foreign_attrs tag.attrs
   in
   let name =
-    if namespace = Some "svg" then Constants.adjust_svg_tag_name tag.name
+    if namespace = Some "svg" then Parser_constants.adjust_svg_tag_name tag.name
     else tag.name
   in
   let node = insert_element t name ~namespace attrs in
···
 let is_html_integration_point node =
   (* SVG foreignObject, desc, and title are always HTML integration points *)
   if node.Dom.namespace = Some "svg" &&
-     List.mem node.Dom.name Constants.svg_html_integration then true
+     List.mem node.Dom.name Parser_constants.svg_html_integration then true
   (* annotation-xml is an HTML integration point only with specific encoding values *)
   else if node.Dom.namespace = Some "mathml" && node.Dom.name = "annotation-xml" then
     match List.assoc_opt "encoding" node.Dom.attrs with
···
   check t.open_elements
 
 let has_element_in_scope t name =
-  has_element_in_scope_impl t [name] Constants.default_scope ~check_integration_points:true
+  has_element_in_scope_impl t [name] Parser_constants.default_scope ~check_integration_points:true
 
 let has_element_in_button_scope t name =
-  has_element_in_scope_impl t [name] Constants.button_scope ~check_integration_points:true
+  has_element_in_scope_impl t [name] Parser_constants.button_scope ~check_integration_points:true
 
 let has_element_in_list_item_scope t name =
-  has_element_in_scope_impl t [name] Constants.list_item_scope ~check_integration_points:true
+  has_element_in_scope_impl t [name] Parser_constants.list_item_scope ~check_integration_points:true
 
 let has_element_in_table_scope t name =
-  has_element_in_scope_impl t [name] Constants.table_scope ~check_integration_points:false
+  has_element_in_scope_impl t [name] Parser_constants.table_scope ~check_integration_points:false
 
 let has_element_in_select_scope t name =
   let rec check = function
     | [] -> false
     | n :: rest ->
       if n.Dom.name = name then true
-      else if not (List.mem n.Dom.name Constants.select_scope_exclude) then false
+      else if not (List.mem n.Dom.name Parser_constants.select_scope_exclude) then false
       else check rest
   in
   check t.open_elements
···
 let generate_implied_end_tags t ?except () =
   let rec loop () =
     match current_node t with
-    | Some n when List.mem n.Dom.name Constants.implied_end_tags ->
+    | Some n when List.mem n.Dom.name Parser_constants.implied_end_tags ->
       (match except with
        | Some ex when n.Dom.name = ex -> ()
        | _ -> pop_current t; loop ())
···
 let generate_all_implied_end_tags t =
   let rec loop () =
     match current_node t with
-    | Some n when List.mem n.Dom.name Constants.thoroughly_implied_end_tags ->
+    | Some n when List.mem n.Dom.name Parser_constants.thoroughly_implied_end_tags ->
       pop_current t; loop ()
     | _ -> ()
   in
···
 (* Reset insertion mode *)
 let reset_insertion_mode t =
   let rec check_node last = function
-    | [] -> t.mode <- Insertion_mode.In_body
+    | [] -> t.mode <- Parser_insertion_mode.In_body
     | node :: rest ->
       let is_last = rest = [] in
       let node_to_check =
···
           let rec find_table_or_template = function
             | [] -> ()
             | n :: rest ->
-              if n.Dom.name = "template" then t.mode <- Insertion_mode.In_select
-              else if n.Dom.name = "table" then t.mode <- Insertion_mode.In_select_in_table
+              if n.Dom.name = "template" then t.mode <- Parser_insertion_mode.In_select
+              else if n.Dom.name = "table" then t.mode <- Parser_insertion_mode.In_select_in_table
               else find_table_or_template rest
           in
           find_table_or_template rest
         end;
-        if t.mode <> Insertion_mode.In_select_in_table then
-          t.mode <- Insertion_mode.In_select
+        if t.mode <> Parser_insertion_mode.In_select_in_table then
+          t.mode <- Parser_insertion_mode.In_select
       end else if List.mem name ["td"; "th"] && not is_last then
-        t.mode <- Insertion_mode.In_cell
+        t.mode <- Parser_insertion_mode.In_cell
       else if name = "tr" then
-        t.mode <- Insertion_mode.In_row
+        t.mode <- Parser_insertion_mode.In_row
       else if List.mem name ["tbody"; "thead"; "tfoot"] then
-        t.mode <- Insertion_mode.In_table_body
+        t.mode <- Parser_insertion_mode.In_table_body
       else if name = "caption" then
-        t.mode <- Insertion_mode.In_caption
+        t.mode <- Parser_insertion_mode.In_caption
       else if name = "colgroup" then
-        t.mode <- Insertion_mode.In_column_group
+        t.mode <- Parser_insertion_mode.In_column_group
       else if name = "table" then
-        t.mode <- Insertion_mode.In_table
+        t.mode <- Parser_insertion_mode.In_table
       else if name = "template" then
-        t.mode <- (match t.template_modes with m :: _ -> m | [] -> Insertion_mode.In_template)
+        t.mode <- (match t.template_modes with m :: _ -> m | [] -> Parser_insertion_mode.In_template)
       else if name = "head" && not is_last then
-        t.mode <- Insertion_mode.In_head
+        t.mode <- Parser_insertion_mode.In_head
       else if name = "body" then
-        t.mode <- Insertion_mode.In_body
+        t.mode <- Parser_insertion_mode.In_body
       else if name = "frameset" then
-        t.mode <- Insertion_mode.In_frameset
+        t.mode <- Parser_insertion_mode.In_frameset
       else if name = "html" then
-        t.mode <- (if t.head_element = None then Insertion_mode.Before_head else Insertion_mode.After_head)
+        t.mode <- (if t.head_element = None then Parser_insertion_mode.Before_head else Parser_insertion_mode.After_head)
       else if is_last then
-        t.mode <- Insertion_mode.In_body
+        t.mode <- Parser_insertion_mode.In_body
       else
         check_node last rest
   in
···
       let sys = Option.map String.lowercase_ascii dt.system_id in
       let is_quirky =
         (match pub with
-         | Some p -> List.mem p Constants.quirky_public_matches ||
+         | Some p -> List.mem p Parser_constants.quirky_public_matches ||
                      List.exists (fun prefix -> String.length p >= String.length prefix &&
-                                                String.sub p 0 (String.length prefix) = prefix) Constants.quirky_public_prefixes
+                                                String.sub p 0 (String.length prefix) = prefix) Parser_constants.quirky_public_prefixes
          | None -> false) ||
         (match sys with
-         | Some s -> List.mem s Constants.quirky_system_matches
+         | Some s -> List.mem s Parser_constants.quirky_system_matches
          | None -> false)
       in
       if is_quirky then t.quirks_mode <- Dom.Quirks
···
           match pub with
           | Some p -> List.exists (fun prefix -> String.length p >= String.length prefix &&
                                                   String.sub p 0 (String.length prefix) = prefix)
-                        Constants.limited_quirky_public_prefixes
+                        Parser_constants.limited_quirky_public_prefixes
           | None -> false
         in
         if is_limited_quirky then t.quirks_mode <- Dom.Limited_quirks
       end
     end;
-    t.mode <- Insertion_mode.Before_html
+    t.mode <- Parser_insertion_mode.Before_html
   | _ ->
     parse_error t "expected-doctype-but-got-other";
     t.quirks_mode <- Dom.Quirks;
-    t.mode <- Insertion_mode.Before_html;
+    t.mode <- Parser_insertion_mode.Before_html;
     process_token t token
 
 and process_before_html t token =
···
   | Token.Tag { kind = Token.Start; name = "html"; attrs; _ } ->
     let html = insert_element t "html" attrs in
     t.open_elements <- [html];
-    t.mode <- Insertion_mode.Before_head
+    t.mode <- Parser_insertion_mode.Before_head
   | Token.Tag { kind = Token.End; name; _ } when List.mem name ["head"; "body"; "html"; "br"] ->
     let html = insert_element t "html" [] in
     t.open_elements <- [html];
-    t.mode <- Insertion_mode.Before_head;
+    t.mode <- Parser_insertion_mode.Before_head;
     process_token t token
   | Token.Tag { kind = Token.End; _ } ->
     parse_error t "unexpected-end-tag"
   | _ ->
     let html = insert_element t "html" [] in
     t.open_elements <- [html];
-    t.mode <- Insertion_mode.Before_head;
+    t.mode <- Parser_insertion_mode.Before_head;
     process_token t token
 
 and process_before_head t token =
···
     let head = insert_element t "head" attrs in
     t.open_elements <- head :: t.open_elements;
     t.head_element <- Some head;
-    t.mode <- Insertion_mode.In_head
+    t.mode <- Parser_insertion_mode.In_head
   | Token.Tag { kind = Token.End; name; _ } when List.mem name ["head"; "body"; "html"; "br"] ->
     let head = insert_element t "head" [] in
     t.open_elements <- head :: t.open_elements;
     t.head_element <- Some head;
-    t.mode <- Insertion_mode.In_head;
+    t.mode <- Parser_insertion_mode.In_head;
     process_token t token
   | Token.Tag { kind = Token.End; _ } ->
     parse_error t "unexpected-end-tag"
···
     let head = insert_element t "head" [] in
     t.open_elements <- head :: t.open_elements;
     t.head_element <- Some head;
-    t.mode <- Insertion_mode.In_head;
+    t.mode <- Parser_insertion_mode.In_head;
     process_token t token
 
 and process_in_head t token =
···
        | Some n when n.Dom.children <> [] -> insert_character t leading_ws
        | _ -> ());
     pop_current t;
-    t.mode <- Insertion_mode.After_head;
+    t.mode <- Parser_insertion_mode.After_head;
     process_token t (Token.Character remaining)
   | Token.Comment data ->
     insert_comment t data
···
   | Token.Tag { kind = Token.Start; name = "title"; _ } ->
     ignore (insert_element_for_token t { kind = Token.Start; name = "title"; attrs = []; self_closing = false });
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["noframes"; "style"] ->
     ignore (insert_element_for_token t { kind = Token.Start; name; attrs = []; self_closing = false });
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.Start; name = "noscript"; _ } ->
     (* Scripting is disabled: parse noscript content as HTML *)
     ignore (insert_element_for_token t { kind = Token.Start; name = "noscript"; attrs = []; self_closing = false });
-    t.mode <- Insertion_mode.In_head_noscript
+    t.mode <- Parser_insertion_mode.In_head_noscript
   | Token.Tag { kind = Token.Start; name = "script"; attrs; self_closing } ->
     ignore (insert_element_for_token t { kind = Token.Start; name = "script"; attrs; self_closing });
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.End; name = "head"; _ } ->
     pop_current t;
-    t.mode <- Insertion_mode.After_head
+    t.mode <- Parser_insertion_mode.After_head
   | Token.Tag { kind = Token.End; name; _ } when List.mem name ["body"; "html"; "br"] ->
     pop_current t;
-    t.mode <- Insertion_mode.After_head;
+    t.mode <- Parser_insertion_mode.After_head;
     process_token t token
   | Token.Tag { kind = Token.Start; name = "template"; attrs; _ } ->
     let node = Dom.create_template ~attrs () in
···
     t.open_elements <- node :: t.open_elements;
     push_formatting_marker t;
     t.frameset_ok <- false;
-    t.mode <- Insertion_mode.In_template;
-    t.template_modes <- Insertion_mode.In_template :: t.template_modes
+    t.mode <- Parser_insertion_mode.In_template;
+    t.template_modes <- Parser_insertion_mode.In_template :: t.template_modes
   | Token.Tag { kind = Token.End; name = "template"; _ } ->
     if not (List.exists (fun n -> n.Dom.name = "template" && is_in_html_namespace n) t.open_elements) then
       parse_error t "unexpected-end-tag"
···
     parse_error t "unexpected-end-tag"
   | _ ->
     pop_current t;
-    t.mode <- Insertion_mode.After_head;
+    t.mode <- Parser_insertion_mode.After_head;
     process_token t token
 
 and process_in_head_noscript t token =
···
   | Token.Character _ ->
     parse_error t "unexpected-char-in-noscript";
     pop_current t;  (* Pop noscript *)
-    t.mode <- Insertion_mode.In_head;
+    t.mode <- Parser_insertion_mode.In_head;
     process_token t token
   | Token.Comment _ ->
     process_in_head t token
···
   | Token.Tag { kind = Token.Start; _ } ->
     parse_error t "unexpected-start-tag";
     pop_current t;  (* Pop noscript *)
-    t.mode <- Insertion_mode.In_head;
+    t.mode <- Parser_insertion_mode.In_head;
     process_token t token
   | Token.Tag { kind = Token.End; name = "noscript"; _ } ->
     pop_current t;  (* Pop noscript *)
-    t.mode <- Insertion_mode.In_head
+    t.mode <- Parser_insertion_mode.In_head
   | Token.Tag { kind = Token.End; name = "br"; _ } ->
     parse_error t "unexpected-end-tag";
     pop_current t;  (* Pop noscript *)
-    t.mode <- Insertion_mode.In_head;
+    t.mode <- Parser_insertion_mode.In_head;
     process_token t token
   | Token.Tag { kind = Token.End; _ } ->
     parse_error t "unexpected-end-tag"
   | Token.EOF ->
     parse_error t "expected-closing-tag-but-got-eof";
     pop_current t;  (* Pop noscript *)
-    t.mode <- Insertion_mode.In_head;
+    t.mode <- Parser_insertion_mode.In_head;
     process_token t token
 
 and process_after_head t token =
···
   | Token.Tag { kind = Token.Start; name = "body"; attrs; _ } ->
     ignore (insert_element t "body" ~push:true attrs);
     t.frameset_ok <- false;
-    t.mode <- Insertion_mode.In_body
+    t.mode <- Parser_insertion_mode.In_body
   | Token.Tag { kind = Token.Start; name = "frameset"; attrs; _ } ->
     ignore (insert_element t "frameset" ~push:true attrs);
-    t.mode <- Insertion_mode.In_frameset
+    t.mode <- Parser_insertion_mode.In_frameset
   | Token.Tag { kind = Token.Start; name = "input"; attrs; _ } ->
     (* Special handling for input type="hidden" - parse error, ignore *)
     let input_type = List.assoc_opt "type" attrs in
···
        (* Non-hidden input creates body *)
        let body = insert_element t "body" [] in
        t.open_elements <- body :: t.open_elements;
-       t.mode <- Insertion_mode.In_body;
+       t.mode <- Parser_insertion_mode.In_body;
        process_token t token)
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["base"; "basefont"; "bgsound"; "link"; "meta"; "noframes"; "script"; "style"; "template"; "title"] ->
···
   | Token.Tag { kind = Token.End; name; _ } when List.mem name ["body"; "html"; "br"] ->
     let body = insert_element t "body" [] in
     t.open_elements <- body :: t.open_elements;
-    t.mode <- Insertion_mode.In_body;
+    t.mode <- Parser_insertion_mode.In_body;
     process_token t token
   | Token.Tag { kind = Token.Start; name = "head"; _ } ->
     parse_error t "unexpected-start-tag"
···
   | _ ->
     let body = insert_element t "body" [] in
     t.open_elements <- body :: t.open_elements;
-    t.mode <- Insertion_mode.In_body;
+    t.mode <- Parser_insertion_mode.In_body;
     process_token t token
 
 and process_in_body t token =
···
         t.open_elements <- drop (idx + 1) t.open_elements;
         (* Insert frameset element *)
         ignore (insert_element t "frameset" ~push:true attrs);
-        t.mode <- Insertion_mode.In_frameset
+        t.mode <- Parser_insertion_mode.In_frameset
     end
   | Token.EOF ->
     if t.template_modes <> [] then
···
         not (List.mem n.Dom.name ["dd"; "dt"; "li"; "optgroup"; "option"; "p"; "rb"; "rp"; "rt"; "rtc"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"; "body"; "html"])
       ) t.open_elements in
       if has_unclosed then parse_error t "end-tag-too-early";
-      t.mode <- Insertion_mode.After_body
+      t.mode <- Parser_insertion_mode.After_body
     end
   | Token.Tag { kind = Token.End; name = "html"; _ } ->
     if not (has_element_in_scope t "body") then
       parse_error t "unexpected-end-tag"
     else begin
-      t.mode <- Insertion_mode.After_body;
+      t.mode <- Parser_insertion_mode.After_body;
       process_token t token
     end
   | Token.Tag { kind = Token.Start; name; attrs; _ }
     when List.mem name ["address"; "article"; "aside"; "blockquote"; "center"; "details"; "dialog"; "dir"; "div"; "dl"; "fieldset"; "figcaption"; "figure"; "footer"; "header"; "hgroup"; "main"; "menu"; "nav"; "ol"; "p"; "search"; "section"; "summary"; "ul"] ->
     if has_element_in_button_scope t "p" then close_p_element t;
     ignore (insert_element t name ~push:true attrs)
-  | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name Constants.heading_elements ->
+  | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name Parser_constants.heading_elements ->
     if has_element_in_button_scope t "p" then close_p_element t;
     (match current_node t with
-     | Some n when List.mem n.Dom.name Constants.heading_elements ->
+     | Some n when List.mem n.Dom.name Parser_constants.heading_elements ->
        parse_error t "unexpected-start-tag";
        pop_current t
      | _ -> ());
···
        | _ -> ());
       pop_until_tag t name
     end
-  | Token.Tag { kind = Token.End; name; _ } when List.mem name Constants.heading_elements ->
-    if not (has_element_in_scope_impl t Constants.heading_elements Constants.default_scope ~check_integration_points:true) then
+  | Token.Tag { kind = Token.End; name; _ } when List.mem name Parser_constants.heading_elements ->
+    if not (has_element_in_scope_impl t Parser_constants.heading_elements Parser_constants.default_scope ~check_integration_points:true) then
       parse_error t "unexpected-end-tag"
     else begin
       generate_implied_end_tags t ();
       (match current_node t with
        | Some n when n.Dom.name <> name -> parse_error t "end-tag-too-early"
        | _ -> ());
-      pop_until_one_of t Constants.heading_elements
+      pop_until_one_of t Parser_constants.heading_elements
     end
   | Token.Tag { kind = Token.Start; name = "a"; attrs; _ } ->
     (* Check for existing <a> in active formatting *)
···
       close_p_element t;
     ignore (insert_element t "table" ~push:true attrs);
     t.frameset_ok <- false;
-    t.mode <- Insertion_mode.In_table
+    t.mode <- Parser_insertion_mode.In_table
   | Token.Tag { kind = Token.End; name = "br"; _ } ->
     parse_error t "unexpected-end-tag";
     reconstruct_active_formatting t;
···
     t.ignore_lf <- true;
     t.original_mode <- Some t.mode;
     t.frameset_ok <- false;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.Start; name = "xmp"; _ } ->
     if has_element_in_button_scope t "p" then close_p_element t;
     reconstruct_active_formatting t;
     t.frameset_ok <- false;
     ignore (insert_element_for_token t { kind = Token.Start; name = "xmp"; attrs = []; self_closing = false });
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.Start; name = "iframe"; _ } ->
     t.frameset_ok <- false;
     ignore (insert_element_for_token t { kind = Token.Start; name = "iframe"; attrs = []; self_closing = false });
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.Start; name = "noembed"; _ } ->
     ignore (insert_element_for_token t { kind = Token.Start; name = "noembed"; attrs = []; self_closing = false });
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.Text
+    t.mode <- Parser_insertion_mode.Text
   | Token.Tag { kind = Token.Start; name = "select"; attrs; _ } ->
     reconstruct_active_formatting t;
     ignore (insert_element t "select" ~push:true attrs);
     t.frameset_ok <- false;
-    if List.mem t.mode [Insertion_mode.In_table; Insertion_mode.In_caption; Insertion_mode.In_table_body; Insertion_mode.In_row; Insertion_mode.In_cell] then
-      t.mode <- Insertion_mode.In_select_in_table
+    if List.mem t.mode [Parser_insertion_mode.In_table; Parser_insertion_mode.In_caption; Parser_insertion_mode.In_table_body; Parser_insertion_mode.In_row; Parser_insertion_mode.In_cell] then
+      t.mode <- Parser_insertion_mode.In_select_in_table
     else
-      t.mode <- Insertion_mode.In_select
+      t.mode <- Parser_insertion_mode.In_select
   | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name ["optgroup"; "option"] ->
     (match current_node t with
      | Some n when n.Dom.name = "option" -> pop_current t
···
     ignore (insert_element t name ~push:true attrs)
   | Token.Tag { kind = Token.Start; name = "math"; attrs; self_closing } ->
     reconstruct_active_formatting t;
-    let adjusted_attrs = Constants.adjust_mathml_attrs (Constants.adjust_foreign_attrs attrs) in
+    let adjusted_attrs = Parser_constants.adjust_mathml_attrs (Parser_constants.adjust_foreign_attrs attrs) in
     ignore (insert_foreign_element t { kind = Token.Start; name = "math"; attrs = adjusted_attrs; self_closing } (Some "mathml"));
     if self_closing then pop_current t
   | Token.Tag { kind = Token.Start; name = "svg"; attrs; self_closing } ->
     reconstruct_active_formatting t;
-    let adjusted_attrs = Constants.adjust_svg_attrs (Constants.adjust_foreign_attrs attrs) in
+    let adjusted_attrs = Parser_constants.adjust_svg_attrs (Parser_constants.adjust_foreign_attrs attrs) in
     ignore (insert_foreign_element t { kind = Token.Start; name = "svg"; attrs = adjusted_attrs; self_closing } (Some "svg"));
     if self_closing then pop_current t
   | Token.Tag { kind = Token.Start; name; attrs; _ }
···
   | Token.EOF ->
     parse_error t "expected-closing-tag-but-got-eof";
     pop_current t;
-    t.mode <- Option.value t.original_mode ~default:Insertion_mode.In_body;
+    t.mode <- Option.value t.original_mode ~default:Parser_insertion_mode.In_body;
     process_token t token
   | Token.Tag { kind = Token.End; _ } ->
     pop_current t;
-    t.mode <- Option.value t.original_mode ~default:Insertion_mode.In_body
+    t.mode <- Option.value t.original_mode ~default:Parser_insertion_mode.In_body
   | _ -> ()
 
 and process_in_table t token =
···
   | Token.Character _ when (match current_node t with Some n -> List.mem n.Dom.name ["table"; "tbody"; "tfoot"; "thead"; "tr"] | None -> false) ->
     t.pending_table_chars <- [];
     t.original_mode <- Some t.mode;
-    t.mode <- Insertion_mode.In_table_text;
+    t.mode <- Parser_insertion_mode.In_table_text;
     process_token t token
   | Token.Comment data ->
     insert_comment t data
···
     clear_stack_back_to_table_context t;
     push_formatting_marker t;
     ignore (insert_element t "caption" ~push:true attrs);
-    t.mode <- Insertion_mode.In_caption
+    t.mode <- Parser_insertion_mode.In_caption
   | Token.Tag { kind = Token.Start; name = "colgroup"; attrs; _ } ->
     clear_stack_back_to_table_context t;
     ignore (insert_element t "colgroup" ~push:true attrs);
-    t.mode <- Insertion_mode.In_column_group
+    t.mode <- Parser_insertion_mode.In_column_group
   | Token.Tag { kind = Token.Start; name = "col"; _ } ->
     clear_stack_back_to_table_context t;
     ignore (insert_element t "colgroup" ~push:true []);
-    t.mode <- Insertion_mode.In_column_group;
+    t.mode <- Parser_insertion_mode.In_column_group;
     process_token t token
   | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name ["tbody"; "tfoot"; "thead"] ->
     clear_stack_back_to_table_context t;
     ignore (insert_element t name ~push:true attrs);
-    t.mode <- Insertion_mode.In_table_body
+    t.mode <- Parser_insertion_mode.In_table_body
   | Token.Tag { kind = Token.Start; name; _ } when List.mem name ["td"; "th"; "tr"] ->
     clear_stack_back_to_table_context t;
     ignore (insert_element t "tbody" ~push:true []);
-    t.mode <- Insertion_mode.In_table_body;
+    t.mode <- Parser_insertion_mode.In_table_body;
     process_token t token
   | Token.Tag { kind = Token.Start; name = "table"; _ } ->
     parse_error t "unexpected-start-tag";
···
       t.foster_parenting <- false
     end else
       insert_character t pending;
-    t.mode <- Option.value t.original_mode ~default:Insertion_mode.In_table;
+    t.mode <- Option.value t.original_mode ~default:Parser_insertion_mode.In_table;
     process_token t token
 
 and process_in_caption t token =
···
        | _ -> ());
       pop_until_tag t "caption";
       clear_active_formatting_to_marker t;
-      t.mode <- Insertion_mode.In_table
+      t.mode <- Parser_insertion_mode.In_table
     end
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["caption"; "col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"] ->
···
       generate_implied_end_tags t ();
       pop_until_tag t "caption";
       clear_active_formatting_to_marker t;
-      t.mode <- Insertion_mode.In_table;
+      t.mode <- Parser_insertion_mode.In_table;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name = "table"; _ } ->
···
       generate_implied_end_tags t ();
       pop_until_tag t "caption";
       clear_active_formatting_to_marker t;
-      t.mode <- Insertion_mode.In_table;
+      t.mode <- Parser_insertion_mode.In_table;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name; _ }
···
       (match current_node t with
        | Some n when n.Dom.name = "colgroup" ->
          pop_current t;
-         t.mode <- Insertion_mode.In_table;
+         t.mode <- Parser_insertion_mode.In_table;
          process_token t (Token.Character remaining)
        | _ ->
          parse_error t "unexpected-token")
···
   | Token.Tag { kind = Token.End; name = "colgroup"; _ } ->
     (match current_node t with
      | Some n when n.Dom.name <> "colgroup" -> parse_error t "unexpected-end-tag"
-     | Some _ -> pop_current t; t.mode <- Insertion_mode.In_table
+     | Some _ -> pop_current t; t.mode <- Parser_insertion_mode.In_table
      | None -> parse_error t "unexpected-end-tag")
   | Token.Tag { kind = Token.End; name = "col"; _ } ->
     parse_error t "unexpected-end-tag"
···
     (match current_node t with
      | Some n when n.Dom.name = "colgroup" ->
        pop_current t;
-       t.mode <- Insertion_mode.In_table;
+       t.mode <- Parser_insertion_mode.In_table;
        process_token t token
      | _ ->
        parse_error t "unexpected-token")
···
   | Token.Tag { kind = Token.Start; name = "tr"; attrs; _ } ->
     clear_stack_back_to_table_body_context t;
     ignore (insert_element t "tr" ~push:true attrs);
-    t.mode <- Insertion_mode.In_row
+    t.mode <- Parser_insertion_mode.In_row
   | Token.Tag { kind = Token.Start; name; _ } when List.mem name ["th"; "td"] ->
     parse_error t "unexpected-start-tag";
     clear_stack_back_to_table_body_context t;
     ignore (insert_element t "tr" ~push:true []);
-    t.mode <- Insertion_mode.In_row;
+    t.mode <- Parser_insertion_mode.In_row;
     process_token t token
   | Token.Tag { kind = Token.End; name; _ } when List.mem name ["tbody"; "tfoot"; "thead"] ->
     if not (has_element_in_table_scope t name) then
···
     else begin
       clear_stack_back_to_table_body_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table
+      t.mode <- Parser_insertion_mode.In_table
     end
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["caption"; "col"; "colgroup"; "tbody"; "tfoot"; "thead"] ->
-    if not (has_element_in_scope_impl t ["tbody"; "tfoot"; "thead"] Constants.table_scope ~check_integration_points:false) then
+    if not (has_element_in_scope_impl t ["tbody"; "tfoot"; "thead"] Parser_constants.table_scope ~check_integration_points:false) then
       parse_error t "unexpected-start-tag"
     else begin
       clear_stack_back_to_table_body_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table;
+      t.mode <- Parser_insertion_mode.In_table;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name = "table"; _ } ->
-    if not (has_element_in_scope_impl t ["tbody"; "tfoot"; "thead"] Constants.table_scope ~check_integration_points:false) then
+    if not (has_element_in_scope_impl t ["tbody"; "tfoot"; "thead"] Parser_constants.table_scope ~check_integration_points:false) then
       parse_error t "unexpected-end-tag"
     else begin
       clear_stack_back_to_table_body_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table;
+      t.mode <- Parser_insertion_mode.In_table;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name; _ }
···
   | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name ["th"; "td"] ->
     clear_stack_back_to_table_row_context t;
     ignore (insert_element t name ~push:true attrs);
-    t.mode <- Insertion_mode.In_cell;
+    t.mode <- Parser_insertion_mode.In_cell;
     push_formatting_marker t
   | Token.Tag { kind = Token.End; name = "tr"; _ } ->
     if not (has_element_in_table_scope t "tr") then
···
     else begin
       clear_stack_back_to_table_row_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table_body
+      t.mode <- Parser_insertion_mode.In_table_body
     end
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["caption"; "col"; "colgroup"; "tbody"; "tfoot"; "thead"; "tr"] ->
···
     else begin
       clear_stack_back_to_table_row_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table_body;
+      t.mode <- Parser_insertion_mode.In_table_body;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name = "table"; _ } ->
···
     else begin
       clear_stack_back_to_table_row_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table_body;
+      t.mode <- Parser_insertion_mode.In_table_body;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name; _ } when List.mem name ["tbody"; "tfoot"; "thead"] ->
···
     else begin
       clear_stack_back_to_table_row_context t;
       pop_current t;
-      t.mode <- Insertion_mode.In_table_body;
+      t.mode <- Parser_insertion_mode.In_table_body;
       process_token t token
     end
   | Token.Tag { kind = Token.End; name; _ }
···
        | _ -> ());
       pop_until_html_tag t name;
       clear_active_formatting_to_marker t;
-      t.mode <- Insertion_mode.In_row
+      t.mode <- Parser_insertion_mode.In_row
     end
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["caption"; "col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"] ->
-    if not (has_element_in_scope_impl t ["td"; "th"] Constants.table_scope ~check_integration_points:false) then
+    if not (has_element_in_scope_impl t ["td"; "th"] Parser_constants.table_scope ~check_integration_points:false) then
       parse_error t "unexpected-start-tag"
     else begin
       close_cell t;
···
    | _ -> ());
   pop_until_html_one_of t ["td"; "th"];
   clear_active_formatting_to_marker t;
-  t.mode <- Insertion_mode.In_row
+  t.mode <- Parser_insertion_mode.In_row
 
 and process_in_select t token =
   match token with
···
     ignore (insert_element t name attrs)
     (* Don't push to stack - void elements *)
   (* Handle formatting elements in select *)
-  | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name Constants.formatting_elements ->
+  | Token.Tag { kind = Token.Start; name; attrs; _ } when List.mem name Parser_constants.formatting_elements ->
     reconstruct_active_formatting t;
     let node = insert_element t name ~push:true attrs in
     push_formatting_element t node name attrs
-  | Token.Tag { kind = Token.End; name; _ } when List.mem name Constants.formatting_elements ->
+  | Token.Tag { kind = Token.End; name; _ } when List.mem name Parser_constants.formatting_elements ->
     (* Find select element and check if formatting element is inside select *)
     let select_idx = ref None in
     let fmt_idx = ref None in
···
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["caption"; "colgroup"; "tbody"; "tfoot"; "thead"] ->
     t.template_modes <- (match t.template_modes with _ :: rest -> rest | [] -> []);
-    t.template_modes <- Insertion_mode.In_table :: t.template_modes;
-    t.mode <- Insertion_mode.In_table;
+    t.template_modes <- Parser_insertion_mode.In_table :: t.template_modes;
+    t.mode <- Parser_insertion_mode.In_table;
     process_token t token
   | Token.Tag { kind = Token.Start; name = "col"; _ } ->
     t.template_modes <- (match t.template_modes with _ :: rest -> rest | [] -> []);
-    t.template_modes <- Insertion_mode.In_column_group :: t.template_modes;
-    t.mode <- Insertion_mode.In_column_group;
+    t.template_modes <- Parser_insertion_mode.In_column_group :: t.template_modes;
+    t.mode <- Parser_insertion_mode.In_column_group;
     process_token t token
   | Token.Tag { kind = Token.Start; name = "tr"; _ } ->
     t.template_modes <- (match t.template_modes with _ :: rest -> rest | [] -> []);
-    t.template_modes <- Insertion_mode.In_table_body :: t.template_modes;
-    t.mode <- Insertion_mode.In_table_body;
+    t.template_modes <- Parser_insertion_mode.In_table_body :: t.template_modes;
+    t.mode <- Parser_insertion_mode.In_table_body;
     process_token t token
   | Token.Tag { kind = Token.Start; name; _ } when List.mem name ["td"; "th"] ->
     t.template_modes <- (match t.template_modes with _ :: rest -> rest | [] -> []);
-    t.template_modes <- Insertion_mode.In_row :: t.template_modes;
-    t.mode <- Insertion_mode.In_row;
+    t.template_modes <- Parser_insertion_mode.In_row :: t.template_modes;
+    t.mode <- Parser_insertion_mode.In_row;
     process_token t token
   | Token.Tag { kind = Token.Start; _ } ->
     t.template_modes <- (match t.template_modes with _ :: rest -> rest | [] -> []);
-    t.template_modes <- Insertion_mode.In_body :: t.template_modes;
-    t.mode <- Insertion_mode.In_body;
+    t.template_modes <- Parser_insertion_mode.In_body :: t.template_modes;
+    t.mode <- Parser_insertion_mode.In_body;
     process_token t token
   | Token.Tag { kind = Token.End; _ } ->
     parse_error t "unexpected-end-tag"
···
     if t.fragment_context <> None then
       parse_error t "unexpected-end-tag"
     else
-      t.mode <- Insertion_mode.After_after_body
+      t.mode <- Parser_insertion_mode.After_after_body
   | Token.EOF ->
     ()  (* Stop parsing *)
   | _ ->
     parse_error t "unexpected-token-after-body";
-    t.mode <- Insertion_mode.In_body;
+    t.mode <- Parser_insertion_mode.In_body;
     process_token t token
 
 and process_in_frameset t token =
···
        pop_current t;
        if t.fragment_context = None then
          (match current_node t with
-          | Some n when n.Dom.name <> "frameset" -> t.mode <- Insertion_mode.After_frameset
+          | Some n when n.Dom.name <> "frameset" -> t.mode <- Parser_insertion_mode.After_frameset
           | _ -> ()))
   | Token.Tag { kind = Token.Start; name = "frame"; attrs; _ } ->
     ignore (insert_element t "frame" ~push:true attrs);
···
   | Token.Tag { kind = Token.Start; name = "html"; _ } ->
     process_in_body t token
   | Token.Tag { kind = Token.End; name = "html"; _ } ->
-    t.mode <- Insertion_mode.After_after_frameset
+    t.mode <- Parser_insertion_mode.After_after_frameset
   | Token.Tag { kind = Token.Start; name = "noframes"; _ } ->
     process_in_head t token
   | Token.EOF ->
···
     ()  (* Stop parsing *)
   | _ ->
     parse_error t "unexpected-token-after-after-body";
-    t.mode <- Insertion_mode.In_body;
+    t.mode <- Parser_insertion_mode.In_body;
     process_token t token
 
 and process_after_after_frameset t token =
···
   let is_html_integration_point node =
     (* SVG foreignObject, desc, and title are always HTML integration points *)
     if node.Dom.namespace = Some "svg" &&
-       List.mem node.Dom.name Constants.svg_html_integration then true
+       List.mem node.Dom.name Parser_constants.svg_html_integration then true
     (* annotation-xml is an HTML integration point only with specific encoding values *)
     else if node.Dom.namespace = Some "mathml" && node.Dom.name = "annotation-xml" then
       match List.assoc_opt "encoding" node.Dom.attrs with
···
   let is_html_integration_point node =
     (* SVG foreignObject, desc, and title are always HTML integration points *)
     if node.Dom.namespace = Some "svg" &&
-       List.mem node.Dom.name Constants.svg_html_integration then true
+       List.mem node.Dom.name Parser_constants.svg_html_integration then true
     (* annotation-xml is an HTML integration point only with specific encoding values *)
     else if node.Dom.namespace = Some "mathml" && node.Dom.name = "annotation-xml" then
       match List.assoc_opt "encoding" node.Dom.attrs with
···
   | Token.Tag { kind = Token.Start; name; attrs; self_closing } ->
     let name =
       match adjusted_current_node t with
-      | Some n when n.Dom.namespace = Some "svg" -> Constants.adjust_svg_tag_name name
+      | Some n when n.Dom.namespace = Some "svg" -> Parser_constants.adjust_svg_tag_name name
       | _ -> name
     in
     let attrs =
       match adjusted_current_node t with
       | Some n when n.Dom.namespace = Some "svg" ->
-        Constants.adjust_svg_attrs (Constants.adjust_foreign_attrs attrs)
+        Parser_constants.adjust_svg_attrs (Parser_constants.adjust_foreign_attrs attrs)
       | Some n when n.Dom.namespace = Some "mathml" ->
-        Constants.adjust_mathml_attrs (Constants.adjust_foreign_attrs attrs)
-      | _ -> Constants.adjust_foreign_attrs attrs
+        Parser_constants.adjust_mathml_attrs (Parser_constants.adjust_foreign_attrs attrs)
+      | _ -> Parser_constants.adjust_foreign_attrs attrs
     in
     let namespace =
       match adjusted_current_node t with
···
 
 and process_by_mode t token =
   match t.mode with
-  | Insertion_mode.Initial -> process_initial t token
-  | Insertion_mode.Before_html -> process_before_html t token
-  | Insertion_mode.Before_head -> process_before_head t token
-  | Insertion_mode.In_head -> process_in_head t token
-  | Insertion_mode.In_head_noscript -> process_in_head_noscript t token
-  | Insertion_mode.After_head -> process_after_head t token
-  | Insertion_mode.In_body -> process_in_body t token
-  | Insertion_mode.Text -> process_text t token
-  | Insertion_mode.In_table -> process_in_table t token
-  | Insertion_mode.In_table_text -> process_in_table_text t token
-  | Insertion_mode.In_caption -> process_in_caption t token
-  | Insertion_mode.In_column_group -> process_in_column_group t token
-  | Insertion_mode.In_table_body -> process_in_table_body t token
-  | Insertion_mode.In_row -> process_in_row t token
-  | Insertion_mode.In_cell -> process_in_cell t token
-  | Insertion_mode.In_select -> process_in_select t token
-  | Insertion_mode.In_select_in_table -> process_in_select_in_table t token
-  | Insertion_mode.In_template -> process_in_template t token
-  | Insertion_mode.After_body -> process_after_body t token
-  | Insertion_mode.In_frameset -> process_in_frameset t token
-  | Insertion_mode.After_frameset -> process_after_frameset t token
-  | Insertion_mode.After_after_body -> process_after_after_body t token
-  | Insertion_mode.After_after_frameset -> process_after_after_frameset t token
+  | Parser_insertion_mode.Initial -> process_initial t token
+  | Parser_insertion_mode.Before_html -> process_before_html t token
+  | Parser_insertion_mode.Before_head -> process_before_head t token
+  | Parser_insertion_mode.In_head -> process_in_head t token
+  | Parser_insertion_mode.In_head_noscript -> process_in_head_noscript t token
+  | Parser_insertion_mode.After_head -> process_after_head t token
+  | Parser_insertion_mode.In_body -> process_in_body t token
+  | Parser_insertion_mode.Text -> process_text t token
+  | Parser_insertion_mode.In_table -> process_in_table t token
+  | Parser_insertion_mode.In_table_text -> process_in_table_text t token
+  | Parser_insertion_mode.In_caption -> process_in_caption t token
+  | Parser_insertion_mode.In_column_group -> process_in_column_group t token
+  | Parser_insertion_mode.In_table_body -> process_in_table_body t token
+  | Parser_insertion_mode.In_row -> process_in_row t token
+  | Parser_insertion_mode.In_cell -> process_in_cell t token
+  | Parser_insertion_mode.In_select -> process_in_select t token
+  | Parser_insertion_mode.In_select_in_table -> process_in_select_in_table t token
+  | Parser_insertion_mode.In_template -> process_in_template t token
+  | Parser_insertion_mode.After_body -> process_after_body t token
+  | Parser_insertion_mode.In_frameset -> process_in_frameset t token
+  | Parser_insertion_mode.After_frameset -> process_after_frameset t token
+  | Parser_insertion_mode.After_after_body -> process_after_after_body t token
+  | Parser_insertion_mode.After_after_frameset -> process_after_after_frameset t token
 
 (* Populate selectedcontent elements with content from selected option *)
 let find_elements name node =

lib/selector/dune

···
-(library
- (name html5rw_selector)
- (public_name html5rw.selector)
- (libraries astring html5rw.dom))

lib/selector/html5rw_selector.mli lib/html5rw/selector/selector.mli

···
     @raise Selector_error if the selector is malformed.
 *)
 
-val query : Html5rw_dom.node -> string -> Html5rw_dom.node list
+val query : Dom.node -> string -> Dom.node list
 (** Query the DOM tree with a CSS selector.
 
     Returns all nodes matching the selector in document order.
···
     ]}
 *)
 
-val matches : Html5rw_dom.node -> string -> bool
+val matches : Dom.node -> string -> bool
 (** Check if a node matches a CSS selector.
 
     @raise Selector_error if the selector is malformed.

lib/selector/selector_match.ml lib/html5rw/selector/selector_match.ml

···
 (* CSS selector matching *)
 
-module Dom = Html5rw_dom
+module Dom = Dom
 open Selector_ast
 
 (* Use Astring for string operations *)

lib/tokenizer/dune

···
-(library
- (name html5rw_tokenizer)
- (public_name html5rw.tokenizer)
- (libraries astring bytesrw html5rw.entities))

lib/tokenizer/html5rw_tokenizer.ml

···
-(* html5rw.tokenizer - HTML5 tokenizer with bytesrw-only API *)
-
-module Token = Token
-module State = State
-module Errors = Errors
-module Stream = Stream
-
-module type SINK = Tokenizer.SINK
-
-type 'a t = 'a Tokenizer.t
-
-let create = Tokenizer.create
-let run = Tokenizer.run
-let get_errors = Tokenizer.get_errors
-let set_state = Tokenizer.set_state
-let set_last_start_tag = Tokenizer.set_last_start_tag

lib/tokenizer/html5rw_tokenizer.mli lib/html5rw/tokenizer/tokenizer.mli

···
 
 (** Token types produced by the tokenizer. *)
 module Token : sig
-  type tag_kind = Token.tag_kind = Start | End
+  type tag_kind = Tokenizer_token.tag_kind = Start | End
 
-  type doctype = Token.doctype = {
+  type doctype = Tokenizer_token.doctype = {
     name : string option;
     public_id : string option;
     system_id : string option;
     force_quirks : bool;
   }
 
-  type tag = Token.tag = {
+  type tag = Tokenizer_token.tag = {
     kind : tag_kind;
     name : string;
     attrs : (string * string) list;
     self_closing : bool;
   }
 
-  type t = Token.t =
+  type t = Tokenizer_token.t =
     | Tag of tag
     | Character of string
     | Comment of string
···
 
 (** Tokenizer states. *)
 module State : sig
-  type t = State.t =
+  type t = Tokenizer_state.t =
     | Data
     | Rcdata
     | Rawtext
···
 
 (** Parse error types. *)
 module Errors : sig
-  type t = Errors.t = {
+  type t = Tokenizer_errors.t = {
     code : string;
     line : int;
     column : int;
···
 
 (** Input stream with position tracking. *)
 module Stream : sig
-  type t = Stream.t
+  type t = Tokenizer_stream.t
 
   val create : string -> t
   val create_from_reader : Bytesrw.Bytes.Reader.t -> t
···
 *)
 module type SINK = sig
   type t
-  val process : t -> Token.t -> [ `Continue | `SwitchTo of State.t ]
+  val process : t -> Tokenizer_token.t -> [ `Continue | `SwitchTo of Tokenizer_state.t ]
   val adjusted_current_node_in_html_namespace : t -> bool
 end
 
···
     function for each token until EOF is reached.
 *)
 
-val get_errors : 'sink t -> Errors.t list
+val get_errors : 'sink t -> Tokenizer_errors.t list
 (** Get the list of parse errors encountered during tokenization.
 
     Only populated if [collect_errors:true] was passed to {!create}.
 *)
 
-val set_state : 'sink t -> State.t -> unit
+val set_state : 'sink t -> Tokenizer_state.t -> unit
 (** Set the tokenizer state.
 
     Used by the tree builder to switch states for raw text elements.

lib/tokenizer/tokenizer.ml

···
-(* HTML5 Tokenizer - implements WHATWG tokenization algorithm *)
-
-(* Character classification using Astring *)
-let is_ascii_alpha = Astring.Char.Ascii.is_letter
-let is_ascii_digit = Astring.Char.Ascii.is_digit
-let is_ascii_hex = Astring.Char.Ascii.is_hex_digit
-let is_ascii_alnum = Astring.Char.Ascii.is_alphanum
-let is_whitespace c = c = ' ' || c = '\t' || c = '\n' || c = '\x0C' || c = '\r'
-let ascii_lower = Astring.Char.Ascii.lowercase
-
-(* Token sink interface *)
-module type SINK = sig
-  type t
-  val process : t -> Token.t -> [ `Continue | `SwitchTo of State.t ]
-  val adjusted_current_node_in_html_namespace : t -> bool
-end
-
-type 'sink t = {
-  mutable stream : Stream.t;
-  sink : 'sink;
-  mutable state : State.t;
-  mutable return_state : State.t;
-  mutable char_ref_code : int;
-  mutable temp_buffer : Buffer.t;
-  mutable last_start_tag : string;
-  mutable current_tag_name : Buffer.t;
-  mutable current_tag_kind : Token.tag_kind;
-  mutable current_tag_self_closing : bool;
-  mutable current_attr_name : Buffer.t;
-  mutable current_attr_value : Buffer.t;
-  mutable current_attrs : (string * string) list;
-  mutable current_doctype_name : Buffer.t option;
-  mutable current_doctype_public : Buffer.t option;
-  mutable current_doctype_system : Buffer.t option;
-  mutable current_doctype_force_quirks : bool;
-  mutable current_comment : Buffer.t;
-  mutable pending_chars : Buffer.t;
-  mutable errors : Errors.t list;
-  collect_errors : bool;
-  xml_mode : bool;  (* XML violation mode: transform chars for XML compatibility *)
-}
-
-let create (type s) (module S : SINK with type t = s) sink ?(collect_errors=false) ?(xml_mode=false) () = {
-  stream = Stream.create "";
-  sink;
-  state = State.Data;
-  return_state = State.Data;
-  char_ref_code = 0;
-  temp_buffer = Buffer.create 64;
-  last_start_tag = "";
-  current_tag_name = Buffer.create 32;
-  current_tag_kind = Token.Start;
-  current_tag_self_closing = false;
-  current_attr_name = Buffer.create 32;
-  current_attr_value = Buffer.create 64;
-  current_attrs = [];
-  current_doctype_name = None;
-  current_doctype_public = None;
-  current_doctype_system = None;
-  current_doctype_force_quirks = false;
-  current_comment = Buffer.create 64;
-  pending_chars = Buffer.create 256;
-  errors = [];
-  collect_errors;
-  xml_mode;
-}
-
-let error t code =
-  if t.collect_errors then begin
-    let (line, column) = Stream.position t.stream in
-    t.errors <- Errors.make ~code ~line ~column :: t.errors
-  end
-
-(* emit functions are defined locally inside run *)
-
-(* XML mode character transformation: form feed → space *)
-let emit_char t c =
-  if t.xml_mode && c = '\x0C' then
-    Buffer.add_char t.pending_chars ' '
-  else
-    Buffer.add_char t.pending_chars c
-
-(* XML mode string transformation: U+FFFF → U+FFFD, form feed → space *)
-let emit_str t s =
-  if t.xml_mode then begin
-    (* Transform: \xEF\xBF\xBF (U+FFFF) → \xEF\xBF\xBD (U+FFFD), \x0C → space *)
-    let len = String.length s in
-    let i = ref 0 in
-    while !i < len do
-      let c = s.[!i] in
-      if c = '\x0C' then begin
-        Buffer.add_char t.pending_chars ' ';
-        incr i
-      end else if c = '\xEF' && !i + 2 < len && s.[!i+1] = '\xBF' && s.[!i+2] = '\xBF' then begin
-        (* U+FFFF → U+FFFD *)
-        Buffer.add_string t.pending_chars "\xEF\xBF\xBD";
-        i := !i + 3
-      end else begin
-        Buffer.add_char t.pending_chars c;
-        incr i
-      end
-    done
-  end else
-    Buffer.add_string t.pending_chars s
-
-let start_new_tag t kind =
-  Buffer.clear t.current_tag_name;
-  t.current_tag_kind <- kind;
-  t.current_tag_self_closing <- false;
-  t.current_attrs <- []
-
-let start_new_attribute t =
-  (* Save previous attribute if any *)
-  let name = Buffer.contents t.current_attr_name in
-  if String.length name > 0 then begin
-    let value = Buffer.contents t.current_attr_value in
-    (* Check for duplicates - only add if not already present *)
-    if not (List.exists (fun (n, _) -> n = name) t.current_attrs) then
-      t.current_attrs <- (name, value) :: t.current_attrs
-    else
-      error t "duplicate-attribute"
-  end;
-  Buffer.clear t.current_attr_name;
-  Buffer.clear t.current_attr_value
-
-let finish_attribute t =
-  start_new_attribute t
-
-let start_new_doctype t =
-  t.current_doctype_name <- None;
-  t.current_doctype_public <- None;
-  t.current_doctype_system <- None;
-  t.current_doctype_force_quirks <- false
-
-(* emit_current_tag, emit_current_doctype, emit_current_comment are defined locally inside run *)
-
-let is_appropriate_end_tag t =
-  let name = Buffer.contents t.current_tag_name in
-  String.length t.last_start_tag > 0 && name = t.last_start_tag
-
-let flush_code_points_consumed_as_char_ref t =
-  let s = Buffer.contents t.temp_buffer in
-  match t.return_state with
-  | State.Attribute_value_double_quoted
-  | State.Attribute_value_single_quoted
-  | State.Attribute_value_unquoted ->
-    Buffer.add_string t.current_attr_value s
-  | _ ->
-    emit_str t s
-
-open Bytesrw
-
-(* Main tokenization loop *)
-let run (type s) t (module S : SINK with type t = s) (reader : Bytes.Reader.t) =
-  t.stream <- Stream.create_from_reader reader;
-  t.errors <- [];
-  (* Set up error callback for surrogate/noncharacter detection in stream *)
-  (* In XML mode, we don't report noncharacter errors - we transform them instead *)
-  if not t.xml_mode then
-    Stream.set_error_callback t.stream (fun code -> error t code);
-
-  (* XML mode transformation for pending chars: U+FFFF → U+FFFD *)
-  let transform_xml_chars data =
-    let len = String.length data in
-    let buf = Buffer.create len in
-    let i = ref 0 in
-    while !i < len do
-      let c = data.[!i] in
-      if c = '\xEF' && !i + 2 < len && data.[!i+1] = '\xBF' && data.[!i+2] = '\xBF' then begin
-        (* U+FFFF → U+FFFD *)
-        Buffer.add_string buf "\xEF\xBF\xBD";
-        i := !i + 3
-      end else begin
-        Buffer.add_char buf c;
-        incr i
-      end
-    done;
-    Buffer.contents buf
-  in
-
-  (* Local emit functions with access to S *)
-  let emit_pending_chars () =
-    if Buffer.length t.pending_chars > 0 then begin
-      let data = Buffer.contents t.pending_chars in
-      Buffer.clear t.pending_chars;
-      let data = if t.xml_mode then transform_xml_chars data else data in
-      ignore (S.process t.sink (Token.Character data))
-    end
-  in
-
-  let emit token =
-    emit_pending_chars ();
-    match S.process t.sink token with
-    | `Continue -> ()
-    | `SwitchTo new_state -> t.state <- new_state
-  in
-
-  let emit_current_tag () =
-    finish_attribute t;
-    let name = Buffer.contents t.current_tag_name in
-    let attrs = List.rev t.current_attrs in
-    (* Check for end tag with attributes or self-closing flag *)
-    if t.current_tag_kind = Token.End then begin
-      if attrs <> [] then
-        error t "end-tag-with-attributes";
-      if t.current_tag_self_closing then
-        error t "end-tag-with-trailing-solidus"
-    end;
-    let tag = {
-      Token.kind = t.current_tag_kind;
-      name;
-      attrs;
-      self_closing = t.current_tag_self_closing;
-    } in
-    if t.current_tag_kind = Token.Start then
-      t.last_start_tag <- name;
-    emit (Token.Tag tag)
-  in
-
-  let emit_current_doctype () =
-    let doctype = {
-      Token.name = Option.map Buffer.contents t.current_doctype_name;
-      public_id = Option.map Buffer.contents t.current_doctype_public;
-      system_id = Option.map Buffer.contents t.current_doctype_system;
-      force_quirks = t.current_doctype_force_quirks;
-    } in
-    emit (Token.Doctype doctype)
-  in
-
-  let emit_current_comment () =
-    let content = Buffer.contents t.current_comment in
-    let content =
-      if t.xml_mode then begin
-        (* XML mode: transform -- to - - in comments *)
-        let buf = Buffer.create (String.length content + 10) in
-        let len = String.length content in
-        let i = ref 0 in
-        while !i < len do
-          if !i + 1 < len && content.[!i] = '-' && content.[!i+1] = '-' then begin
-            Buffer.add_string buf "- -";
-            i := !i + 2
-          end else begin
-            Buffer.add_char buf content.[!i];
-            incr i
-          end
-        done;
-        Buffer.contents buf
-      end else content
-    in
-    emit (Token.Comment content)
-  in
-
-  (* Check for control characters and emit error if needed *)
-  (* Only checks ASCII control chars; C1 controls (U+0080-U+009F) are 2-byte in UTF-8 *)
-  let check_control_char c =
-    let code = Char.code c in
-    (* Control chars: U+0001-U+0008, U+000B, U+000E-U+001F, U+007F *)
-    (* Allowed: U+0009 (tab), U+000A (LF), U+000C (FF), U+000D (CR) *)
-    (* Note: U+0080-U+009F (C1 controls) are 2-byte UTF-8 sequences starting with 0xC2 *)
-    (* Note: We only check single-byte control chars here; multi-byte checks are TODO *)
-    if (code >= 0x01 && code <= 0x08) ||
-       code = 0x0B ||
-       (code >= 0x0E && code <= 0x1F) ||
-       code = 0x7F then
-      error t "control-character-in-input-stream"
-  in
-
-
-  (* Emit char with control character check *)
-  let emit_char_checked c =
-    check_control_char c;
-    emit_char t c
-  in
-
-  let rec process_state () =
-    if Stream.is_eof t.stream && t.state <> State.Data then begin
-      (* Handle EOF in various states *)
-      handle_eof ()
-    end else if Stream.is_eof t.stream then begin
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    end else begin
-      step ();
-      process_state ()
-    end
-
-  and handle_eof () =
-    match t.state with
-    | State.Data ->
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Tag_open ->
-      error t "eof-before-tag-name";
-      emit_char t '<';
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.End_tag_open ->
-      error t "eof-before-tag-name";
-      emit_str t "</";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Tag_name
-    | State.Before_attribute_name
-    | State.Attribute_name
-    | State.After_attribute_name
-    | State.Before_attribute_value
-    | State.Attribute_value_double_quoted
-    | State.Attribute_value_single_quoted
-    | State.Attribute_value_unquoted
-    | State.After_attribute_value_quoted
-    | State.Self_closing_start_tag ->
-      error t "eof-in-tag";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rawtext ->
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rawtext_less_than_sign ->
-      emit_char t '<';
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rawtext_end_tag_open ->
-      emit_str t "</";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rawtext_end_tag_name ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rcdata ->
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rcdata_less_than_sign ->
-      emit_char t '<';
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rcdata_end_tag_open ->
-      emit_str t "</";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Rcdata_end_tag_name ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data ->
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_less_than_sign ->
-      emit_char t '<';
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_end_tag_open ->
-      emit_str t "</";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_end_tag_name ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_escape_start
-    | State.Script_data_escape_start_dash
-    | State.Script_data_escaped
-    | State.Script_data_escaped_dash
-    | State.Script_data_escaped_dash_dash ->
-      error t "eof-in-script-html-comment-like-text";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_escaped_less_than_sign ->
-      emit_char t '<';
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_escaped_end_tag_open ->
-      emit_str t "</";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_escaped_end_tag_name ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_double_escape_start
-    | State.Script_data_double_escaped
-    | State.Script_data_double_escaped_dash
-    | State.Script_data_double_escaped_dash_dash ->
-      error t "eof-in-script-html-comment-like-text";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_double_escaped_less_than_sign ->
-      (* '<' was already emitted when entering this state from Script_data_double_escaped *)
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Script_data_double_escape_end ->
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Plaintext ->
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Comment_start
-    | State.Comment_start_dash
-    | State.Comment
-    | State.Comment_less_than_sign
-    | State.Comment_less_than_sign_bang
-    | State.Comment_less_than_sign_bang_dash
-    | State.Comment_less_than_sign_bang_dash_dash
-    | State.Comment_end_dash
-    | State.Comment_end
-    | State.Comment_end_bang ->
-      error t "eof-in-comment";
-      emit_current_comment ();
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Bogus_comment ->
-      emit_current_comment ();
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Markup_declaration_open ->
-      error t "incorrectly-opened-comment";
-      Buffer.clear t.current_comment;
-      emit_current_comment ();
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Doctype
-    | State.Before_doctype_name ->
-      error t "eof-in-doctype";
-      start_new_doctype t;
-      t.current_doctype_force_quirks <- true;
-      emit_current_doctype ();
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Doctype_name
-    | State.After_doctype_name
-    | State.After_doctype_public_keyword
-    | State.Before_doctype_public_identifier
-    | State.Doctype_public_identifier_double_quoted
-    | State.Doctype_public_identifier_single_quoted
-    | State.After_doctype_public_identifier
-    | State.Between_doctype_public_and_system_identifiers
-    | State.After_doctype_system_keyword
-    | State.Before_doctype_system_identifier
-    | State.Doctype_system_identifier_double_quoted
-    | State.Doctype_system_identifier_single_quoted
-    | State.After_doctype_system_identifier ->
-      error t "eof-in-doctype";
-      t.current_doctype_force_quirks <- true;
-      emit_current_doctype ();
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Bogus_doctype ->
-      emit_current_doctype ();
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Cdata_section ->
-      error t "eof-in-cdata";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Cdata_section_bracket ->
-      error t "eof-in-cdata";
-      emit_char t ']';
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Cdata_section_end ->
-      error t "eof-in-cdata";
-      emit_str t "]]";
-      emit_pending_chars ();
-      ignore (S.process t.sink Token.EOF)
-    | State.Character_reference ->
-      (* state_character_reference never ran, so initialize temp_buffer with & *)
-      Buffer.clear t.temp_buffer;
-      Buffer.add_char t.temp_buffer '&';
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state;
-      handle_eof ()
-    | State.Named_character_reference ->
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state;
-      handle_eof ()
-    | State.Numeric_character_reference ->
-      (* At EOF with just "&#" - no digits follow *)
-      error t "absence-of-digits-in-numeric-character-reference";
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state;
-      handle_eof ()
-    | State.Hexadecimal_character_reference_start
-    | State.Decimal_character_reference_start ->
-      error t "absence-of-digits-in-numeric-character-reference";
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state;
-      handle_eof ()
-    | State.Numeric_character_reference_end ->
-      (* We have collected digits, just need to finalize the character reference *)
-      step ();
-      handle_eof ()
-    | State.Ambiguous_ampersand ->
-      (* Buffer was already flushed when entering this state, just transition *)
-      t.state <- t.return_state;
-      handle_eof ()
-    | State.Hexadecimal_character_reference
-    | State.Decimal_character_reference ->
-      (* At EOF with collected digits - convert the numeric reference *)
-      error t "missing-semicolon-after-character-reference";
-      let code = t.char_ref_code in
-      let replacement_char = "\xEF\xBF\xBD" in
-      let result =
-        if code = 0 then begin
-          error t "null-character-reference";
-          replacement_char
-        end else if code > 0x10FFFF then begin
-          error t "character-reference-outside-unicode-range";
-          replacement_char
-        end else if code >= 0xD800 && code <= 0xDFFF then begin
-          error t "surrogate-character-reference";
-          replacement_char
-        end else
-          Html5rw_entities.Numeric_ref.codepoint_to_utf8 code
-      in
-      Buffer.clear t.temp_buffer;
-      Buffer.add_string t.temp_buffer result;
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state;
-      handle_eof ()
-
-  and step () =
-    match t.state with
-    | State.Data -> state_data ()
-    | State.Rcdata -> state_rcdata ()
-    | State.Rawtext -> state_rawtext ()
-    | State.Script_data -> state_script_data ()
-    | State.Plaintext -> state_plaintext ()
-    | State.Tag_open -> state_tag_open ()
-    | State.End_tag_open -> state_end_tag_open ()
-    | State.Tag_name -> state_tag_name ()
-    | State.Rcdata_less_than_sign -> state_rcdata_less_than_sign ()
-    | State.Rcdata_end_tag_open -> state_rcdata_end_tag_open ()
-    | State.Rcdata_end_tag_name -> state_rcdata_end_tag_name ()
-    | State.Rawtext_less_than_sign -> state_rawtext_less_than_sign ()
-    | State.Rawtext_end_tag_open -> state_rawtext_end_tag_open ()
-    | State.Rawtext_end_tag_name -> state_rawtext_end_tag_name ()
-    | State.Script_data_less_than_sign -> state_script_data_less_than_sign ()
-    | State.Script_data_end_tag_open -> state_script_data_end_tag_open ()
-    | State.Script_data_end_tag_name -> state_script_data_end_tag_name ()
-    | State.Script_data_escape_start -> state_script_data_escape_start ()
-    | State.Script_data_escape_start_dash -> state_script_data_escape_start_dash ()
-    | State.Script_data_escaped -> state_script_data_escaped ()
-    | State.Script_data_escaped_dash -> state_script_data_escaped_dash ()
-    | State.Script_data_escaped_dash_dash -> state_script_data_escaped_dash_dash ()
-    | State.Script_data_escaped_less_than_sign -> state_script_data_escaped_less_than_sign ()
-    | State.Script_data_escaped_end_tag_open -> state_script_data_escaped_end_tag_open ()
-    | State.Script_data_escaped_end_tag_name -> state_script_data_escaped_end_tag_name ()
-    | State.Script_data_double_escape_start -> state_script_data_double_escape_start ()
-    | State.Script_data_double_escaped -> state_script_data_double_escaped ()
-    | State.Script_data_double_escaped_dash -> state_script_data_double_escaped_dash ()
-    | State.Script_data_double_escaped_dash_dash -> state_script_data_double_escaped_dash_dash ()
-    | State.Script_data_double_escaped_less_than_sign -> state_script_data_double_escaped_less_than_sign ()
-    | State.Script_data_double_escape_end -> state_script_data_double_escape_end ()
-    | State.Before_attribute_name -> state_before_attribute_name ()
-    | State.Attribute_name -> state_attribute_name ()
-    | State.After_attribute_name -> state_after_attribute_name ()
-    | State.Before_attribute_value -> state_before_attribute_value ()
-    | State.Attribute_value_double_quoted -> state_attribute_value_double_quoted ()
-    | State.Attribute_value_single_quoted -> state_attribute_value_single_quoted ()
-    | State.Attribute_value_unquoted -> state_attribute_value_unquoted ()
-    | State.After_attribute_value_quoted -> state_after_attribute_value_quoted ()
-    | State.Self_closing_start_tag -> state_self_closing_start_tag ()
-    | State.Bogus_comment -> state_bogus_comment ()
-    | State.Markup_declaration_open -> state_markup_declaration_open ()
-    | State.Comment_start -> state_comment_start ()
-    | State.Comment_start_dash -> state_comment_start_dash ()
-    | State.Comment -> state_comment ()
-    | State.Comment_less_than_sign -> state_comment_less_than_sign ()
-    | State.Comment_less_than_sign_bang -> state_comment_less_than_sign_bang ()
-    | State.Comment_less_than_sign_bang_dash -> state_comment_less_than_sign_bang_dash ()
-    | State.Comment_less_than_sign_bang_dash_dash -> state_comment_less_than_sign_bang_dash_dash ()
-    | State.Comment_end_dash -> state_comment_end_dash ()
-    | State.Comment_end -> state_comment_end ()
-    | State.Comment_end_bang -> state_comment_end_bang ()
-    | State.Doctype -> state_doctype ()
-    | State.Before_doctype_name -> state_before_doctype_name ()
-    | State.Doctype_name -> state_doctype_name ()
-    | State.After_doctype_name -> state_after_doctype_name ()
-    | State.After_doctype_public_keyword -> state_after_doctype_public_keyword ()
-    | State.Before_doctype_public_identifier -> state_before_doctype_public_identifier ()
-    | State.Doctype_public_identifier_double_quoted -> state_doctype_public_identifier_double_quoted ()
-    | State.Doctype_public_identifier_single_quoted -> state_doctype_public_identifier_single_quoted ()
-    | State.After_doctype_public_identifier -> state_after_doctype_public_identifier ()
-    | State.Between_doctype_public_and_system_identifiers -> state_between_doctype_public_and_system_identifiers ()
-    | State.After_doctype_system_keyword -> state_after_doctype_system_keyword ()
-    | State.Before_doctype_system_identifier -> state_before_doctype_system_identifier ()
-    | State.Doctype_system_identifier_double_quoted -> state_doctype_system_identifier_double_quoted ()
-    | State.Doctype_system_identifier_single_quoted -> state_doctype_system_identifier_single_quoted ()
-    | State.After_doctype_system_identifier -> state_after_doctype_system_identifier ()
-    | State.Bogus_doctype -> state_bogus_doctype ()
-    | State.Cdata_section -> state_cdata_section ()
-    | State.Cdata_section_bracket -> state_cdata_section_bracket ()
-    | State.Cdata_section_end -> state_cdata_section_end ()
-    | State.Character_reference -> state_character_reference ()
-    | State.Named_character_reference -> state_named_character_reference ()
-    | State.Ambiguous_ampersand -> state_ambiguous_ampersand ()
-    | State.Numeric_character_reference -> state_numeric_character_reference ()
-    | State.Hexadecimal_character_reference_start -> state_hexadecimal_character_reference_start ()
-    | State.Decimal_character_reference_start -> state_decimal_character_reference_start ()
-    | State.Hexadecimal_character_reference -> state_hexadecimal_character_reference ()
-    | State.Decimal_character_reference -> state_decimal_character_reference ()
-    | State.Numeric_character_reference_end -> state_numeric_character_reference_end ()
-
-  (* State implementations *)
-  and state_data () =
-    match Stream.consume t.stream with
-    | Some '&' ->
-      t.return_state <- State.Data;
-      t.state <- State.Character_reference
-    | Some '<' ->
-      t.state <- State.Tag_open
-    | Some '\x00' ->
-      (* Emit pending chars first, then emit null separately for proper tree builder handling *)
-      emit_pending_chars ();
-      error t "unexpected-null-character";
-      ignore (S.process t.sink (Token.Character "\x00"))
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_rcdata () =
-    match Stream.consume t.stream with
-    | Some '&' ->
-      t.return_state <- State.Rcdata;
-      t.state <- State.Character_reference
-    | Some '<' ->
-      t.state <- State.Rcdata_less_than_sign
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_rawtext () =
-    match Stream.consume t.stream with
-    | Some '<' ->
-      t.state <- State.Rawtext_less_than_sign
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data () =
-    match Stream.consume t.stream with
-    | Some '<' ->
-      t.state <- State.Script_data_less_than_sign
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_plaintext () =
-    match Stream.consume t.stream with
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_tag_open () =
-    match Stream.peek t.stream with
-    | Some '!' ->
-      Stream.advance t.stream;
-      t.state <- State.Markup_declaration_open
-    | Some '/' ->
-      Stream.advance t.stream;
-      t.state <- State.End_tag_open
-    | Some c when is_ascii_alpha c ->
-      start_new_tag t Token.Start;
-      t.state <- State.Tag_name
-    | Some '?' ->
-      error t "unexpected-question-mark-instead-of-tag-name";
-      Buffer.clear t.current_comment;
-      t.state <- State.Bogus_comment
-    | None ->
-      error t "eof-before-tag-name";
-      emit_char t '<'
-    | Some _ ->
-      error t "invalid-first-character-of-tag-name";
-      emit_char t '<';
-      t.state <- State.Data
-
-  and state_end_tag_open () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alpha c ->
-      start_new_tag t Token.End;
-      t.state <- State.Tag_name
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-end-tag-name";
-      t.state <- State.Data
-    | None ->
-      error t "eof-before-tag-name";
-      emit_str t "</"
-    | Some _ ->
-      error t "invalid-first-character-of-tag-name";
-      Buffer.clear t.current_comment;
-      t.state <- State.Bogus_comment
-
-  and state_tag_name () =
-    match Stream.consume t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      t.state <- State.Before_attribute_name
-    | Some '/' ->
-      t.state <- State.Self_closing_start_tag
-    | Some '>' ->
-      t.state <- State.Data;
-      emit_current_tag ()
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_tag_name "\xEF\xBF\xBD"
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char t.current_tag_name (ascii_lower c)
-    | None -> ()
-
-  and state_rcdata_less_than_sign () =
-    match Stream.peek t.stream with
-    | Some '/' ->
-      Stream.advance t.stream;
-      Buffer.clear t.temp_buffer;
-      t.state <- State.Rcdata_end_tag_open
-    | _ ->
-      emit_char t '<';
-      t.state <- State.Rcdata
-
-  and state_rcdata_end_tag_open () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alpha c ->
-      start_new_tag t Token.End;
-      t.state <- State.Rcdata_end_tag_name
-    | _ ->
-      emit_str t "</";
-      t.state <- State.Rcdata
-
-  and state_rcdata_end_tag_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_name
-    | Some '/' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Self_closing_start_tag
-    | Some '>' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | Some c when is_ascii_alpha c ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_tag_name (ascii_lower c);
-      Buffer.add_char t.temp_buffer c
-    | _ ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      t.state <- State.Rcdata
-
-  and state_rawtext_less_than_sign () =
-    match Stream.peek t.stream with
-    | Some '/' ->
-      Stream.advance t.stream;
-      Buffer.clear t.temp_buffer;
-      t.state <- State.Rawtext_end_tag_open
-    | _ ->
-      emit_char t '<';
-      t.state <- State.Rawtext
-
-  and state_rawtext_end_tag_open () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alpha c ->
-      start_new_tag t Token.End;
-      t.state <- State.Rawtext_end_tag_name
-    | _ ->
-      emit_str t "</";
-      t.state <- State.Rawtext
-
-  and state_rawtext_end_tag_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_name
-    | Some '/' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Self_closing_start_tag
-    | Some '>' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | Some c when is_ascii_alpha c ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_tag_name (ascii_lower c);
-      Buffer.add_char t.temp_buffer c
-    | _ ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      t.state <- State.Rawtext
-
-  and state_script_data_less_than_sign () =
-    match Stream.peek t.stream with
-    | Some '/' ->
-      Stream.advance t.stream;
-      Buffer.clear t.temp_buffer;
-      t.state <- State.Script_data_end_tag_open
-    | Some '!' ->
-      Stream.advance t.stream;
-      t.state <- State.Script_data_escape_start;
-      emit_str t "<!"
-    | _ ->
-      emit_char t '<';
-      t.state <- State.Script_data
-
-  and state_script_data_end_tag_open () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alpha c ->
-      start_new_tag t Token.End;
-      t.state <- State.Script_data_end_tag_name
-    | _ ->
-      emit_str t "</";
-      t.state <- State.Script_data
-
-  and state_script_data_end_tag_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_name
-    | Some '/' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Self_closing_start_tag
-    | Some '>' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | Some c when is_ascii_alpha c ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_tag_name (ascii_lower c);
-      Buffer.add_char t.temp_buffer c
-    | _ ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      t.state <- State.Script_data
-
-  and state_script_data_escape_start () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Script_data_escape_start_dash;
-      emit_char t '-'
-    | _ ->
-      t.state <- State.Script_data
-
-  and state_script_data_escape_start_dash () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Script_data_escaped_dash_dash;
-      emit_char t '-'
-    | _ ->
-      t.state <- State.Script_data
-
-  and state_script_data_escaped () =
-    match Stream.consume t.stream with
-    | Some '-' ->
-      t.state <- State.Script_data_escaped_dash;
-      emit_char t '-'
-    | Some '<' ->
-      t.state <- State.Script_data_escaped_less_than_sign
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data_escaped_dash () =
-    match Stream.consume t.stream with
-    | Some '-' ->
-      t.state <- State.Script_data_escaped_dash_dash;
-      emit_char t '-'
-    | Some '<' ->
-      t.state <- State.Script_data_escaped_less_than_sign
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      t.state <- State.Script_data_escaped;
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      t.state <- State.Script_data_escaped;
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data_escaped_dash_dash () =
-    match Stream.consume t.stream with
-    | Some '-' ->
-      emit_char t '-'
-    | Some '<' ->
-      t.state <- State.Script_data_escaped_less_than_sign
-    | Some '>' ->
-      t.state <- State.Script_data;
-      emit_char t '>'
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      t.state <- State.Script_data_escaped;
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      t.state <- State.Script_data_escaped;
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data_escaped_less_than_sign () =
-    match Stream.peek t.stream with
-    | Some '/' ->
-      Stream.advance t.stream;
-      Buffer.clear t.temp_buffer;
-      t.state <- State.Script_data_escaped_end_tag_open
-    | Some c when is_ascii_alpha c ->
-      Buffer.clear t.temp_buffer;
-      emit_char t '<';
-      t.state <- State.Script_data_double_escape_start
-    | _ ->
-      emit_char t '<';
-      t.state <- State.Script_data_escaped
-
-  and state_script_data_escaped_end_tag_open () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alpha c ->
-      start_new_tag t Token.End;
-      t.state <- State.Script_data_escaped_end_tag_name
-    | _ ->
-      emit_str t "</";
-      t.state <- State.Script_data_escaped
-
-  and state_script_data_escaped_end_tag_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_name
-    | Some '/' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Self_closing_start_tag
-    | Some '>' when is_appropriate_end_tag t ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | Some c when is_ascii_alpha c ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_tag_name (ascii_lower c);
-      Buffer.add_char t.temp_buffer c
-    | _ ->
-      emit_str t "</";
-      emit_str t (Buffer.contents t.temp_buffer);
-      t.state <- State.Script_data_escaped
-
-  and state_script_data_double_escape_start () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ' | '/' | '>') as c_opt ->
-      Stream.advance t.stream;
-      let c = Option.get c_opt in
-      if Buffer.contents t.temp_buffer = "script" then
-        t.state <- State.Script_data_double_escaped
-      else
-        t.state <- State.Script_data_escaped;
-      emit_char t c
-    | Some c when is_ascii_alpha c ->
-      Stream.advance t.stream;
-      Buffer.add_char t.temp_buffer (ascii_lower c);
-      emit_char t c
-    | _ ->
-      t.state <- State.Script_data_escaped
-
-  and state_script_data_double_escaped () =
-    match Stream.consume t.stream with
-    | Some '-' ->
-      t.state <- State.Script_data_double_escaped_dash;
-      emit_char t '-'
-    | Some '<' ->
-      t.state <- State.Script_data_double_escaped_less_than_sign;
-      emit_char t '<'
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data_double_escaped_dash () =
-    match Stream.consume t.stream with
-    | Some '-' ->
-      t.state <- State.Script_data_double_escaped_dash_dash;
-      emit_char t '-'
-    | Some '<' ->
-      t.state <- State.Script_data_double_escaped_less_than_sign;
-      emit_char t '<'
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      t.state <- State.Script_data_double_escaped;
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      t.state <- State.Script_data_double_escaped;
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data_double_escaped_dash_dash () =
-    match Stream.consume t.stream with
-    | Some '-' ->
-      emit_char t '-'
-    | Some '<' ->
-      t.state <- State.Script_data_double_escaped_less_than_sign;
-      emit_char t '<'
-    | Some '>' ->
-      t.state <- State.Script_data;
-      emit_char t '>'
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      t.state <- State.Script_data_double_escaped;
-      emit_str t "\xEF\xBF\xBD"
-    | Some c ->
-      t.state <- State.Script_data_double_escaped;
-      emit_char_checked c
-    | None -> ()
-
-  and state_script_data_double_escaped_less_than_sign () =
-    match Stream.peek t.stream with
-    | Some '/' ->
-      Stream.advance t.stream;
-      Buffer.clear t.temp_buffer;
-      t.state <- State.Script_data_double_escape_end;
-      emit_char t '/'
-    | _ ->
-      t.state <- State.Script_data_double_escaped
-
-  and state_script_data_double_escape_end () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ' | '/' | '>') as c_opt ->
-      Stream.advance t.stream;
-      let c = Option.get c_opt in
-      if Buffer.contents t.temp_buffer = "script" then
-        t.state <- State.Script_data_escaped
-      else
-        t.state <- State.Script_data_double_escaped;
-      emit_char t c
-    | Some c when is_ascii_alpha c ->
-      Stream.advance t.stream;
-      Buffer.add_char t.temp_buffer (ascii_lower c);
-      emit_char t c
-    | _ ->
-      t.state <- State.Script_data_double_escaped
-
-  and state_before_attribute_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '/' | Some '>' | None ->
-      t.state <- State.After_attribute_name
-    | Some '=' ->
-      Stream.advance t.stream;
-      error t "unexpected-equals-sign-before-attribute-name";
-      start_new_attribute t;
-      Buffer.add_char t.current_attr_name '=';
-      t.state <- State.Attribute_name
-    | Some _ ->
-      start_new_attribute t;
-      t.state <- State.Attribute_name
-
-  and state_attribute_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.After_attribute_name
-    | Some '/' | Some '>' | None ->
-      t.state <- State.After_attribute_name
-    | Some '=' ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_value
-    | Some '\x00' ->
-      Stream.advance t.stream;
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_attr_name "\xEF\xBF\xBD"
-    | Some ('"' | '\'' | '<') as c_opt ->
-      Stream.advance t.stream;
-      error t "unexpected-character-in-attribute-name";
-      Buffer.add_char t.current_attr_name (Option.get c_opt)
-    | Some c ->
-      Stream.advance t.stream;
-      check_control_char c;
-      Buffer.add_char t.current_attr_name (ascii_lower c)
-
-  and state_after_attribute_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '/' ->
-      Stream.advance t.stream;
-      t.state <- State.Self_closing_start_tag
-    | Some '=' ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_value
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | None -> ()
-    | Some _ ->
-      start_new_attribute t;
-      t.state <- State.Attribute_name
-
-  and state_before_attribute_value () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '"' ->
-      Stream.advance t.stream;
-      t.state <- State.Attribute_value_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      t.state <- State.Attribute_value_single_quoted
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-attribute-value";
-      t.state <- State.Data;
-      emit_current_tag ()
-    | _ ->
-      t.state <- State.Attribute_value_unquoted
-
-  and state_attribute_value_double_quoted () =
-    match Stream.consume t.stream with
-    | Some '"' ->
-      t.state <- State.After_attribute_value_quoted
-    | Some '&' ->
-      t.return_state <- State.Attribute_value_double_quoted;
-      t.state <- State.Character_reference
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_attr_value "\xEF\xBF\xBD"
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char t.current_attr_value c
-    | None -> ()
-
-  and state_attribute_value_single_quoted () =
-    match Stream.consume t.stream with
-    | Some '\'' ->
-      t.state <- State.After_attribute_value_quoted
-    | Some '&' ->
-      t.return_state <- State.Attribute_value_single_quoted;
-      t.state <- State.Character_reference
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_attr_value "\xEF\xBF\xBD"
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char t.current_attr_value c
-    | None -> ()
-
-  and state_attribute_value_unquoted () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_name
-    | Some '&' ->
-      Stream.advance t.stream;
-      t.return_state <- State.Attribute_value_unquoted;
-      t.state <- State.Character_reference
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | Some '\x00' ->
-      Stream.advance t.stream;
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_attr_value "\xEF\xBF\xBD"
-    | Some ('"' | '\'' | '<' | '=' | '`') as c_opt ->
-      Stream.advance t.stream;
-      error t "unexpected-character-in-unquoted-attribute-value";
-      Buffer.add_char t.current_attr_value (Option.get c_opt)
-    | Some c ->
-      Stream.advance t.stream;
-      check_control_char c;
-      Buffer.add_char t.current_attr_value c
-    | None -> ()
-
-  and state_after_attribute_value_quoted () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.Before_attribute_name
-    | Some '/' ->
-      Stream.advance t.stream;
-      t.state <- State.Self_closing_start_tag
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | None -> ()
-    | Some _ ->
-      error t "missing-whitespace-between-attributes";
-      t.state <- State.Before_attribute_name
-
-  and state_self_closing_start_tag () =
-    match Stream.peek t.stream with
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.current_tag_self_closing <- true;
-      t.state <- State.Data;
-      emit_current_tag ()
-    | None -> ()
-    | Some _ ->
-      error t "unexpected-solidus-in-tag";
-      t.state <- State.Before_attribute_name
-
-  and state_bogus_comment () =
-    match Stream.consume t.stream with
-    | Some '>' ->
-      t.state <- State.Data;
-      emit_current_comment ()
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_comment "\xEF\xBF\xBD"
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char t.current_comment c
-    | None -> ()
-
-  and state_markup_declaration_open () =
-    if Stream.matches_ci t.stream "--" then begin
-      ignore (Stream.consume_exact_ci t.stream "--");
-      Buffer.clear t.current_comment;
-      t.state <- State.Comment_start
-    end else if Stream.matches_ci t.stream "DOCTYPE" then begin
-      ignore (Stream.consume_exact_ci t.stream "DOCTYPE");
-      t.state <- State.Doctype
-    end else if Stream.matches_ci t.stream "[CDATA[" then begin
-      ignore (Stream.consume_exact_ci t.stream "[CDATA[");
-      (* CDATA only allowed in foreign content *)
-      if S.adjusted_current_node_in_html_namespace t.sink then begin
-        error t "cdata-in-html-content";
-        Buffer.clear t.current_comment;
-        Buffer.add_string t.current_comment "[CDATA[";
-        t.state <- State.Bogus_comment
-      end else
-        t.state <- State.Cdata_section
-    end else begin
-      error t "incorrectly-opened-comment";
-      Buffer.clear t.current_comment;
-      t.state <- State.Bogus_comment
-    end
-
-  and state_comment_start () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Comment_start_dash
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "abrupt-closing-of-empty-comment";
-      t.state <- State.Data;
-      emit_current_comment ()
-    | _ ->
-      t.state <- State.Comment
-
-  and state_comment_start_dash () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Comment_end
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "abrupt-closing-of-empty-comment";
-      t.state <- State.Data;
-      emit_current_comment ()
-    | None -> ()
-    | Some _ ->
-      Buffer.add_char t.current_comment '-';
-      t.state <- State.Comment
-
-  and state_comment () =
-    match Stream.consume t.stream with
-    | Some '<' ->
-      Buffer.add_char t.current_comment '<';
-      t.state <- State.Comment_less_than_sign
-    | Some '-' ->
-      t.state <- State.Comment_end_dash
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string t.current_comment "\xEF\xBF\xBD"
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char t.current_comment c
-    | None -> ()
-
-  and state_comment_less_than_sign () =
-    match Stream.peek t.stream with
-    | Some '!' ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_comment '!';
-      t.state <- State.Comment_less_than_sign_bang
-    | Some '<' ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_comment '<'
-    | _ ->
-      t.state <- State.Comment
-
-  and state_comment_less_than_sign_bang () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Comment_less_than_sign_bang_dash
-    | _ ->
-      t.state <- State.Comment
-
-  and state_comment_less_than_sign_bang_dash () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Comment_less_than_sign_bang_dash_dash
-    | _ ->
-      t.state <- State.Comment_end_dash
-
-  and state_comment_less_than_sign_bang_dash_dash () =
-    match Stream.peek t.stream with
-    | Some '>' | None ->
-      t.state <- State.Comment_end
-    | Some _ ->
-      error t "nested-comment";
-      t.state <- State.Comment_end
-
-  and state_comment_end_dash () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      t.state <- State.Comment_end
-    | None -> ()
-    | Some _ ->
-      Buffer.add_char t.current_comment '-';
-      t.state <- State.Comment
-
-  and state_comment_end () =
-    match Stream.peek t.stream with
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_comment ()
-    | Some '!' ->
-      Stream.advance t.stream;
-      t.state <- State.Comment_end_bang
-    | Some '-' ->
-      Stream.advance t.stream;
-      Buffer.add_char t.current_comment '-'
-    | None -> ()
-    | Some _ ->
-      Buffer.add_string t.current_comment "--";
-      t.state <- State.Comment
-
-  and state_comment_end_bang () =
-    match Stream.peek t.stream with
-    | Some '-' ->
-      Stream.advance t.stream;
-      Buffer.add_string t.current_comment "--!";
-      t.state <- State.Comment_end_dash
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "incorrectly-closed-comment";
-      t.state <- State.Data;
-      emit_current_comment ()
-    | None -> ()
-    | Some _ ->
-      Buffer.add_string t.current_comment "--!";
-      t.state <- State.Comment
-
-  and state_doctype () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.Before_doctype_name
-    | Some '>' ->
-      t.state <- State.Before_doctype_name
-    | None -> ()
-    | Some _ ->
-      error t "missing-whitespace-before-doctype-name";
-      t.state <- State.Before_doctype_name
-
-  and state_before_doctype_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '\x00' ->
-      Stream.advance t.stream;
-      error t "unexpected-null-character";
-      start_new_doctype t;
-      t.current_doctype_name <- Some (Buffer.create 8);
-      Buffer.add_string (Option.get t.current_doctype_name) "\xEF\xBF\xBD";
-      t.state <- State.Doctype_name
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-doctype-name";
-      start_new_doctype t;
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some c ->
-      Stream.advance t.stream;
-      check_control_char c;
-      start_new_doctype t;
-      t.current_doctype_name <- Some (Buffer.create 8);
-      Buffer.add_char (Option.get t.current_doctype_name) (ascii_lower c);
-      t.state <- State.Doctype_name
-
-  and state_doctype_name () =
-    match Stream.consume t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      t.state <- State.After_doctype_name
-    | Some '>' ->
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string (Option.get t.current_doctype_name) "\xEF\xBF\xBD"
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char (Option.get t.current_doctype_name) (ascii_lower c)
-    | None -> ()
-
-  and state_after_doctype_name () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      if Stream.matches_ci t.stream "PUBLIC" then begin
-        ignore (Stream.consume_exact_ci t.stream "PUBLIC");
-        t.state <- State.After_doctype_public_keyword
-      end else if Stream.matches_ci t.stream "SYSTEM" then begin
-        ignore (Stream.consume_exact_ci t.stream "SYSTEM");
-        t.state <- State.After_doctype_system_keyword
-      end else begin
-        error t "invalid-character-sequence-after-doctype-name";
-        t.current_doctype_force_quirks <- true;
-        t.state <- State.Bogus_doctype
-      end
-
-  and state_after_doctype_public_keyword () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.Before_doctype_public_identifier
-    | Some '"' ->
-      Stream.advance t.stream;
-      error t "missing-whitespace-after-doctype-public-keyword";
-      t.current_doctype_public <- Some (Buffer.create 32);
-      t.state <- State.Doctype_public_identifier_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      error t "missing-whitespace-after-doctype-public-keyword";
-      t.current_doctype_public <- Some (Buffer.create 32);
-      t.state <- State.Doctype_public_identifier_single_quoted
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-doctype-public-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      error t "missing-quote-before-doctype-public-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Bogus_doctype
-
-  and state_before_doctype_public_identifier () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '"' ->
-      Stream.advance t.stream;
-      t.current_doctype_public <- Some (Buffer.create 32);
-      t.state <- State.Doctype_public_identifier_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      t.current_doctype_public <- Some (Buffer.create 32);
-      t.state <- State.Doctype_public_identifier_single_quoted
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-doctype-public-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some _ ->
-      error t "missing-quote-before-doctype-public-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Bogus_doctype
-
-  and state_doctype_public_identifier_double_quoted () =
-    match Stream.consume t.stream with
-    | Some '"' ->
-      t.state <- State.After_doctype_public_identifier
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string (Option.get t.current_doctype_public) "\xEF\xBF\xBD"
-    | Some '>' ->
-      error t "abrupt-doctype-public-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char (Option.get t.current_doctype_public) c
-    | None -> ()
-
-  and state_doctype_public_identifier_single_quoted () =
-    match Stream.consume t.stream with
-    | Some '\'' ->
-      t.state <- State.After_doctype_public_identifier
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string (Option.get t.current_doctype_public) "\xEF\xBF\xBD"
-    | Some '>' ->
-      error t "abrupt-doctype-public-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char (Option.get t.current_doctype_public) c
-    | None -> ()
-
-  and state_after_doctype_public_identifier () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.Between_doctype_public_and_system_identifiers
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some '"' ->
-      Stream.advance t.stream;
-      error t "missing-whitespace-between-doctype-public-and-system-identifiers";
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      error t "missing-whitespace-between-doctype-public-and-system-identifiers";
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_single_quoted
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      error t "missing-quote-before-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Bogus_doctype
-
-  and state_between_doctype_public_and_system_identifiers () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some '"' ->
-      Stream.advance t.stream;
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_single_quoted
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      error t "missing-quote-before-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Bogus_doctype
-
-  and state_after_doctype_system_keyword () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream;
-      t.state <- State.Before_doctype_system_identifier
-    | Some '"' ->
-      Stream.advance t.stream;
-      error t "missing-whitespace-after-doctype-system-keyword";
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      error t "missing-whitespace-after-doctype-system-keyword";
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_single_quoted
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      error t "missing-quote-before-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Bogus_doctype
-
-  and state_before_doctype_system_identifier () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '"' ->
-      Stream.advance t.stream;
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_double_quoted
-    | Some '\'' ->
-      Stream.advance t.stream;
-      t.current_doctype_system <- Some (Buffer.create 32);
-      t.state <- State.Doctype_system_identifier_single_quoted
-    | Some '>' ->
-      Stream.advance t.stream;
-      error t "missing-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      error t "missing-quote-before-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Bogus_doctype
-
-  and state_doctype_system_identifier_double_quoted () =
-    match Stream.consume t.stream with
-    | Some '"' ->
-      t.state <- State.After_doctype_system_identifier
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string (Option.get t.current_doctype_system) "\xEF\xBF\xBD"
-    | Some '>' ->
-      error t "abrupt-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char (Option.get t.current_doctype_system) c
-    | None -> ()
-
-  and state_doctype_system_identifier_single_quoted () =
-    match Stream.consume t.stream with
-    | Some '\'' ->
-      t.state <- State.After_doctype_system_identifier
-    | Some '\x00' ->
-      error t "unexpected-null-character";
-      Buffer.add_string (Option.get t.current_doctype_system) "\xEF\xBF\xBD"
-    | Some '>' ->
-      error t "abrupt-doctype-system-identifier";
-      t.current_doctype_force_quirks <- true;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some c ->
-      check_control_char c;
-      Buffer.add_char (Option.get t.current_doctype_system) c
-    | None -> ()
-
-  and state_after_doctype_system_identifier () =
-    match Stream.peek t.stream with
-    | Some ('\t' | '\n' | '\x0C' | ' ') ->
-      Stream.advance t.stream
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | None -> ()
-    | Some _ ->
-      (* Don't check control char here - bogus_doctype will check when it consumes *)
-      error t "unexpected-character-after-doctype-system-identifier";
-      t.state <- State.Bogus_doctype
-
-  and state_bogus_doctype () =
-    match Stream.consume t.stream with
-    | Some '>' ->
-      t.state <- State.Data;
-      emit_current_doctype ()
-    | Some '\x00' ->
-      error t "unexpected-null-character"
-    | Some c ->
-      check_control_char c  (* Check all chars in bogus doctype *)
-    | None -> ()
-
-  and state_cdata_section () =
-    match Stream.consume t.stream with
-    | Some ']' ->
-      t.state <- State.Cdata_section_bracket
-    | Some c ->
-      (* CDATA section emits all characters as-is, including NUL, but still check for control chars *)
-      emit_char_checked c
-    | None -> ()
-
-  and state_cdata_section_bracket () =
-    match Stream.peek t.stream with
-    | Some ']' ->
-      Stream.advance t.stream;
-      t.state <- State.Cdata_section_end
-    | _ ->
-      emit_char t ']';
-      t.state <- State.Cdata_section
-
-  and state_cdata_section_end () =
-    match Stream.peek t.stream with
-    | Some ']' ->
-      Stream.advance t.stream;
-      emit_char t ']'
-    | Some '>' ->
-      Stream.advance t.stream;
-      t.state <- State.Data
-    | _ ->
-      emit_str t "]]";
-      t.state <- State.Cdata_section
-
-  and state_character_reference () =
-    Buffer.clear t.temp_buffer;
-    Buffer.add_char t.temp_buffer '&';
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alnum c ->
-      t.state <- State.Named_character_reference
-    | Some '#' ->
-      Stream.advance t.stream;
-      Buffer.add_char t.temp_buffer '#';
-      t.state <- State.Numeric_character_reference
-    | _ ->
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state
-
-  and state_named_character_reference () =
-    (* Collect alphanumeric characters *)
-    let rec collect () =
-      match Stream.peek t.stream with
-      | Some c when is_ascii_alnum c ->
-        Stream.advance t.stream;
-        Buffer.add_char t.temp_buffer c;
-        collect ()
-      | _ -> ()
-    in
-    collect ();
-
-    let has_semicolon =
-      match Stream.peek t.stream with
-      | Some ';' -> Stream.advance t.stream; Buffer.add_char t.temp_buffer ';'; true
-      | _ -> false
-    in
-
-    (* Try to match entity - buffer contains "&name" or "&name;" *)
-    let buf_contents = Buffer.contents t.temp_buffer in
-    let name_start = 1 in (* Skip '&' *)
-    let name_end = String.length buf_contents - (if has_semicolon then 1 else 0) in
-    let entity_name = String.sub buf_contents name_start (name_end - name_start) in
-
-    (* Try progressively shorter matches *)
-    (* Only match if:
-       1. Full match with semicolon, OR
-       2. Legacy entity (can be used without semicolon) *)
-    let rec try_match len =
-      if len <= 0 then None
-      else
-        let prefix = String.sub entity_name 0 len in
-        let is_full = len = String.length entity_name in
-        let would_have_semi = has_semicolon && is_full in
-        (* Only use this match if it has semicolon or is a legacy entity *)
-        if would_have_semi || Html5rw_entities.is_legacy prefix then
-          match Html5rw_entities.lookup prefix with
-          | Some decoded -> Some (decoded, len)
-          | None -> try_match (len - 1)
-        else
-          try_match (len - 1)
-    in
-
-    match try_match (String.length entity_name) with
-    | Some (decoded, matched_len) ->
-      let full_match = matched_len = String.length entity_name in
-      let ends_with_semi = has_semicolon && full_match in
-
-      (* Check attribute context restrictions *)
-      let in_attribute = match t.return_state with
-        | State.Attribute_value_double_quoted
-        | State.Attribute_value_single_quoted
-        | State.Attribute_value_unquoted -> true
-        | _ -> false
-      in
-
-      let next_char =
-        if full_match && not has_semicolon then
-          Stream.peek t.stream
-        else if not full_match then
-          Some entity_name.[matched_len]
-        else None
-      in
-
-      let blocked = in_attribute && not ends_with_semi &&
-        match next_char with
-        | Some '=' -> true
-        | Some c when is_ascii_alnum c -> true
-        | _ -> false
-      in
-
-      if blocked then begin
-        flush_code_points_consumed_as_char_ref t;
-        t.state <- t.return_state
-      end else begin
-        if not ends_with_semi then
-          error t "missing-semicolon-after-character-reference";
-        Buffer.clear t.temp_buffer;
-        Buffer.add_string t.temp_buffer decoded;
-        flush_code_points_consumed_as_char_ref t;
-        (* Emit unconsumed chars after partial match *)
-        if not full_match then begin
-          let unconsumed = String.sub entity_name matched_len (String.length entity_name - matched_len) in
-          emit_str t unconsumed;
-          (* If there was a semicolon in input but we didn't use the full match, emit the semicolon too *)
-          if has_semicolon then
-            emit_char t ';'
-        end;
-        t.state <- t.return_state
-      end
-    | None ->
-      (* No match - check if we should report unknown-named-character-reference *)
-      if String.length entity_name > 0 then begin
-        (* If we have a semicolon, it's definitely an unknown named character reference *)
-        if has_semicolon then
-          error t "unknown-named-character-reference";
-        (* Emit all the chars we consumed *)
-        flush_code_points_consumed_as_char_ref t;
-        t.state <- t.return_state
-      end else begin
-        flush_code_points_consumed_as_char_ref t;
-        t.state <- t.return_state
-      end
-
-  and state_ambiguous_ampersand () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_alnum c ->
-      Stream.advance t.stream;
-      (match t.return_state with
-      | State.Attribute_value_double_quoted
-      | State.Attribute_value_single_quoted
-      | State.Attribute_value_unquoted ->
-        Buffer.add_char t.current_attr_value c
-      | _ ->
-        emit_char t c)
-    | Some ';' ->
-      error t "unknown-named-character-reference";
-      t.state <- t.return_state
-    | _ ->
-      t.state <- t.return_state
-
-  and state_numeric_character_reference () =
-    t.char_ref_code <- 0;
-    match Stream.peek t.stream with
-    | Some (('x' | 'X') as c) ->
-      Stream.advance t.stream;
-      Buffer.add_char t.temp_buffer c;
-      t.state <- State.Hexadecimal_character_reference_start
-    | _ ->
-      t.state <- State.Decimal_character_reference_start
-
-  and state_hexadecimal_character_reference_start () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_hex c ->
-      t.state <- State.Hexadecimal_character_reference
-    | _ ->
-      error t "absence-of-digits-in-numeric-character-reference";
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state
-
-  and state_decimal_character_reference_start () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_digit c ->
-      t.state <- State.Decimal_character_reference
-    | _ ->
-      error t "absence-of-digits-in-numeric-character-reference";
-      flush_code_points_consumed_as_char_ref t;
-      t.state <- t.return_state
-
-  and state_hexadecimal_character_reference () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_digit c ->
-      Stream.advance t.stream;
-      t.char_ref_code <- t.char_ref_code * 16 + (Char.code c - Char.code '0');
-      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
-    | Some c when c >= 'A' && c <= 'F' ->
-      Stream.advance t.stream;
-      t.char_ref_code <- t.char_ref_code * 16 + (Char.code c - Char.code 'A' + 10);
-      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
-    | Some c when c >= 'a' && c <= 'f' ->
-      Stream.advance t.stream;
-      t.char_ref_code <- t.char_ref_code * 16 + (Char.code c - Char.code 'a' + 10);
-      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
-    | Some ';' ->
-      Stream.advance t.stream;
-      t.state <- State.Numeric_character_reference_end
-    | _ ->
-      error t "missing-semicolon-after-character-reference";
-      t.state <- State.Numeric_character_reference_end
-
-  and state_decimal_character_reference () =
-    match Stream.peek t.stream with
-    | Some c when is_ascii_digit c ->
-      Stream.advance t.stream;
-      t.char_ref_code <- t.char_ref_code * 10 + (Char.code c - Char.code '0');
-      if t.char_ref_code > 0x10FFFF then t.char_ref_code <- 0x10FFFF + 1
-    | Some ';' ->
-      Stream.advance t.stream;
-      t.state <- State.Numeric_character_reference_end
-    | _ ->
-      error t "missing-semicolon-after-character-reference";
-      t.state <- State.Numeric_character_reference_end
-
-  and state_numeric_character_reference_end () =
-    let code = t.char_ref_code in
-    let replacement_char = "\xEF\xBF\xBD" in
-
-    let result =
-      if code = 0 then begin
-        error t "null-character-reference";
-        replacement_char
-      end else if code > 0x10FFFF then begin
-        error t "character-reference-outside-unicode-range";
-        replacement_char
-      end else if code >= 0xD800 && code <= 0xDFFF then begin
-        error t "surrogate-character-reference";
-        replacement_char
-      end else if (code >= 0xFDD0 && code <= 0xFDEF) ||
-                  List.mem code [0xFFFE; 0xFFFF; 0x1FFFE; 0x1FFFF; 0x2FFFE; 0x2FFFF;
-                                 0x3FFFE; 0x3FFFF; 0x4FFFE; 0x4FFFF; 0x5FFFE; 0x5FFFF;
-                                 0x6FFFE; 0x6FFFF; 0x7FFFE; 0x7FFFF; 0x8FFFE; 0x8FFFF;
-                                 0x9FFFE; 0x9FFFF; 0xAFFFE; 0xAFFFF; 0xBFFFE; 0xBFFFF;
-                                 0xCFFFE; 0xCFFFF; 0xDFFFE; 0xDFFFF; 0xEFFFE; 0xEFFFF;
-                                 0xFFFFE; 0xFFFFF; 0x10FFFE; 0x10FFFF] then begin
-        error t "noncharacter-character-reference";
-        Html5rw_entities.Numeric_ref.codepoint_to_utf8 code
-      end else if (code >= 0x01 && code <= 0x08) || code = 0x0B ||
-                  (code >= 0x0D && code <= 0x1F) ||
-                  (code >= 0x7F && code <= 0x9F) then begin
-        error t "control-character-reference";
-        (* Apply Windows-1252 replacement table for 0x80-0x9F *)
-        match Html5rw_entities.Numeric_ref.find_replacement code with
-        | Some replacement -> Html5rw_entities.Numeric_ref.codepoint_to_utf8 replacement
-        | None -> Html5rw_entities.Numeric_ref.codepoint_to_utf8 code
-      end else
-        Html5rw_entities.Numeric_ref.codepoint_to_utf8 code
-    in
-
-    Buffer.clear t.temp_buffer;
-    Buffer.add_string t.temp_buffer result;
-    flush_code_points_consumed_as_char_ref t;
-    t.state <- t.return_state
-
-  in
-  process_state ()
-
-let get_errors t = List.rev t.errors
-
-let set_state t state = t.state <- state
-
-let set_last_start_tag t name = t.last_start_tag <- name

test/dune

···
 (executable
  (name test_all)
  (modules test_all)
- (libraries bytesrw html5rw.parser html5rw.dom html5rw.tokenizer html5rw.encoding jsont jsont.bytesrw test_report))
+ (libraries bytesrw html5rw jsont jsont.bytesrw test_report))
 
 (executable
  (name test_html5lib)
  (modules test_html5lib)
- (libraries bytesrw html5rw.parser html5rw.dom test_report))
+ (libraries bytesrw html5rw test_report))
 
 (rule
  (alias runtest)
···
 (executable
  (name test_tokenizer)
  (modules test_tokenizer)
- (libraries bytesrw html5rw.tokenizer jsont jsont.bytesrw test_report))
+ (libraries bytesrw html5rw jsont jsont.bytesrw test_report))
 
 (rule
  (alias runtest)
···
 (executable
  (name test_encoding)
  (modules test_encoding)
- (libraries html5rw.encoding test_report))
+ (libraries html5rw test_report))
 
 (rule
  (alias runtest)
···
 (executable
  (name test_serializer)
  (modules test_serializer)
- (libraries html5rw.dom jsont jsont.bytesrw test_report))
+ (libraries html5rw jsont jsont.bytesrw test_report))
 
 (rule
  (alias runtest)

test/test_all.ml

···
 (* ============================================================ *)
 
 module TreeConstruction = struct
-  module Parser = Html5rw_parser
-  module Dom = Html5rw_dom
+  module Parser = Html5rw.Parser
+  module Dom = Html5rw.Dom
 
   type test_case = {
     input : string;
···
             | [tag] -> (None, tag)
             | _ -> (None, ctx_str)
           in
-          let context = Parser.make_fragment_context ~tag_name ~namespace () in
+          let context = Html5rw.Parser.make_fragment_context ~tag_name ~namespace () in
           let reader = Bytes.Reader.of_string test.input in
-          Parser.parse ~collect_errors:true ~fragment_context:context reader
+          Html5rw.Parser.parse ~collect_errors:true ~fragment_context:context reader
         | None ->
           let reader = Bytes.Reader.of_string test.input in
-          Parser.parse ~collect_errors:true reader
+          Html5rw.Parser.parse ~collect_errors:true reader
       in
-      let actual_tree = Dom.to_test_format (Parser.root result) in
+      let actual_tree = Html5rw.Dom.to_test_format (Html5rw.Parser.root result) in
       let expected = normalize_tree (strip_tree_prefix test.expected_tree) in
       let actual = normalize_tree (strip_tree_prefix actual_tree) in
-      let error_count = List.length (Parser.errors result) in
+      let error_count = List.length (Html5rw.Parser.errors result) in
       let expected_error_count = List.length test.expected_errors in
       (expected = actual, expected, actual, error_count, expected_error_count)
     with e ->
···
 (* ============================================================ *)
 
 module Tokenizer_tests = struct
-  module Tokenizer = Html5rw_tokenizer
+  module Tokenizer = Html5rw.Tokenizer
 
   module TokenCollector = struct
-    type t = { mutable tokens : Tokenizer.Token.t list }
+    type t = { mutable tokens : Html5rw.Tokenizer.Token.t list }
     let create () = { tokens = [] }
     let process t token = t.tokens <- token :: t.tokens; `Continue
     let adjusted_current_node_in_html_namespace _ = true
···
       last_start_tag; double_escaped; xml_mode; raw_json }
 
   let state_of_string = function
-    | "Data state" -> Tokenizer.State.Data
-    | "PLAINTEXT state" -> Tokenizer.State.Plaintext
-    | "RCDATA state" -> Tokenizer.State.Rcdata
-    | "RAWTEXT state" -> Tokenizer.State.Rawtext
-    | "Script data state" -> Tokenizer.State.Script_data
-    | "CDATA section state" -> Tokenizer.State.Cdata_section
+    | "Data state" -> Html5rw.Tokenizer.State.Data
+    | "PLAINTEXT state" -> Html5rw.Tokenizer.State.Plaintext
+    | "RCDATA state" -> Html5rw.Tokenizer.State.Rcdata
+    | "RAWTEXT state" -> Html5rw.Tokenizer.State.Rawtext
+    | "Script data state" -> Html5rw.Tokenizer.State.Script_data
+    | "CDATA section state" -> Html5rw.Tokenizer.State.Cdata_section
     | s -> failwith ("Unknown state: " ^ s)
 
-  let token_to_test_json (tok : Tokenizer.Token.t) : Jsont.json list =
+  let token_to_test_json (tok : Html5rw.Tokenizer.Token.t) : Jsont.json list =
     let str s = Jsont.String (s, Jsont.Meta.none) in
     let arr l = Jsont.Array (l, Jsont.Meta.none) in
     match tok with
-    | Tokenizer.Token.Doctype { name; public_id; system_id; force_quirks } ->
+    | Html5rw.Tokenizer.Token.Doctype { name; public_id; system_id; force_quirks } ->
       let name_json = match name with Some n -> str n | None -> Jsont.Null ((), Jsont.Meta.none) in
       let public_json = match public_id with Some p -> str p | None -> Jsont.Null ((), Jsont.Meta.none) in
       let system_json = match system_id with Some s -> str s | None -> Jsont.Null ((), Jsont.Meta.none) in
       let correctness = Jsont.Bool (not force_quirks, Jsont.Meta.none) in
       [arr [str "DOCTYPE"; name_json; public_json; system_json; correctness]]
-    | Tokenizer.Token.Tag { kind = Start; name; attrs; self_closing } ->
+    | Html5rw.Tokenizer.Token.Tag { kind = Start; name; attrs; self_closing } ->
       let attrs_obj = Jsont.Object (
         List.map (fun (n, v) -> ((n, Jsont.Meta.none), str v)) (List.rev attrs),
         Jsont.Meta.none
       ) in
       if self_closing then [arr [str "StartTag"; str name; attrs_obj; Jsont.Bool (true, Jsont.Meta.none)]]
       else [arr [str "StartTag"; str name; attrs_obj]]
-    | Tokenizer.Token.Tag { kind = End; name; _ } -> [arr [str "EndTag"; str name]]
-    | Tokenizer.Token.Comment data -> [arr [str "Comment"; str data]]
-    | Tokenizer.Token.Character data -> [arr [str "Character"; str data]]
-    | Tokenizer.Token.EOF -> []
+    | Html5rw.Tokenizer.Token.Tag { kind = End; name; _ } -> [arr [str "EndTag"; str name]]
+    | Html5rw.Tokenizer.Token.Comment data -> [arr [str "Comment"; str data]]
+    | Html5rw.Tokenizer.Token.Character data -> [arr [str "Character"; str data]]
+    | Html5rw.Tokenizer.Token.EOF -> []
 
   let rec json_equal a b =
     match a, b with
···
   let merge_character_tokens tokens =
     let rec loop acc = function
       | [] -> List.rev acc
-      | Tokenizer.Token.Character s1 :: Tokenizer.Token.Character s2 :: rest ->
-        loop acc (Tokenizer.Token.Character (s1 ^ s2) :: rest)
+      | Html5rw.Tokenizer.Token.Character s1 :: Html5rw.Tokenizer.Token.Character s2 :: rest ->
+        loop acc (Html5rw.Tokenizer.Token.Character (s1 ^ s2) :: rest)
       | tok :: rest -> loop (tok :: acc) rest
     in loop [] tokens
 
   let run_test test initial_state =
     let input = if test.double_escaped then unescape_double test.input else test.input in
     let collector = TokenCollector.create () in
-    let tokenizer = Tokenizer.create (module TokenCollector) collector ~collect_errors:true ~xml_mode:test.xml_mode () in
-    Tokenizer.set_state tokenizer initial_state;
-    (match test.last_start_tag with Some tag -> Tokenizer.set_last_start_tag tokenizer tag | None -> ());
+    let tokenizer = Html5rw.Tokenizer.create (module TokenCollector) collector ~collect_errors:true ~xml_mode:test.xml_mode () in
+    Html5rw.Tokenizer.set_state tokenizer initial_state;
+    (match test.last_start_tag with Some tag -> Html5rw.Tokenizer.set_last_start_tag tokenizer tag | None -> ());
     let reader = Bytes.Reader.of_string input in
-    Tokenizer.run tokenizer (module TokenCollector) reader;
+    Html5rw.Tokenizer.run tokenizer (module TokenCollector) reader;
     let tokens = merge_character_tokens (TokenCollector.get_tokens collector) in
     let actual_tokens = List.concat_map token_to_test_json tokens in
     let expected_output = if test.double_escaped then
···
       List.length actual_tokens = List.length expected &&
       List.for_all2 json_equal actual_tokens expected
     in
-    let actual_error_count = List.length (Tokenizer.get_errors tokenizer) in
+    let actual_error_count = List.length (Html5rw.Tokenizer.get_errors tokenizer) in
     let errors_count_match = actual_error_count = test.expected_error_count in
     (tokens_match && errors_count_match, actual_tokens, expected, actual_error_count, test.expected_error_count)
 
···
 (* ============================================================ *)
 
 module Encoding_tests = struct
-  module Encoding = Html5rw_encoding
+  module Encoding = Html5rw.Encoding
 
   type test_case = {
     input : string;
···
   let normalize_encoding_name s = String.lowercase_ascii (String.trim s)
 
   let encoding_to_test_name = function
-    | Encoding.Utf8 -> "utf-8"
-    | Encoding.Utf16le -> "utf-16le"
-    | Encoding.Utf16be -> "utf-16be"
-    | Encoding.Windows_1252 -> "windows-1252"
-    | Encoding.Iso_8859_2 -> "iso-8859-2"
-    | Encoding.Euc_jp -> "euc-jp"
+    | Html5rw.Encoding.Utf8 -> "utf-8"
+    | Html5rw.Encoding.Utf16le -> "utf-16le"
+    | Html5rw.Encoding.Utf16be -> "utf-16be"
+    | Html5rw.Encoding.Windows_1252 -> "windows-1252"
+    | Html5rw.Encoding.Iso_8859_2 -> "iso-8859-2"
+    | Html5rw.Encoding.Euc_jp -> "euc-jp"
 
   let parse_test_case lines =
     let raw_lines = String.concat "\n" lines in
···
 
   let run_test test =
     try
-      let (_, detected_encoding) = Encoding.decode (Bytes.of_string test.input) () in
+      let (_, detected_encoding) = Html5rw.Encoding.decode (Bytes.of_string test.input) () in
       let detected_name = encoding_to_test_name detected_encoding in
       let expected_name = normalize_encoding_name test.expected_encoding in
       let match_encoding det exp =

test/test_encoding.ml

···
 (* Test runner for html5lib-tests encoding tests *)
 
-module Encoding = Html5rw_encoding
+module Encoding = Html5rw.Encoding
 module Report = Test_report
 
 type test_case = {
···
 
 (* Convert our encoding type to canonical test name *)
 let encoding_to_test_name = function
-  | Encoding.Utf8 -> "utf-8"
-  | Encoding.Utf16le -> "utf-16le"
-  | Encoding.Utf16be -> "utf-16be"
-  | Encoding.Windows_1252 -> "windows-1252"
-  | Encoding.Iso_8859_2 -> "iso-8859-2"
-  | Encoding.Euc_jp -> "euc-jp"
+  | Html5rw.Encoding.Utf8 -> "utf-8"
+  | Html5rw.Encoding.Utf16le -> "utf-16le"
+  | Html5rw.Encoding.Utf16be -> "utf-16be"
+  | Html5rw.Encoding.Windows_1252 -> "windows-1252"
+  | Html5rw.Encoding.Iso_8859_2 -> "iso-8859-2"
+  | Html5rw.Encoding.Euc_jp -> "euc-jp"
 
 (* Parse a single test case from lines *)
 let parse_test_case lines =
···
 let run_test test =
   try
     (* Detect encoding from the input bytes *)
-    let (_, detected_encoding) = Encoding.decode (Bytes.of_string test.input) () in
+    let (_, detected_encoding) = Html5rw.Encoding.decode (Bytes.of_string test.input) () in
     let detected_name = encoding_to_test_name detected_encoding in
     let expected_name = normalize_encoding_name test.expected_encoding in
 

test/test_html5lib.ml

···
 
 open Bytesrw
 
-module Parser = Html5rw_parser
-module Dom = Html5rw_dom
+module Parser = Html5rw.Parser
+module Dom = Html5rw.Dom
 module Report = Test_report
 
 type test_case = {
···
           | [tag] -> (None, tag)
           | _ -> (None, ctx_str)
         in
-        let context = Parser.make_fragment_context ~tag_name ~namespace () in
+        let context = Html5rw.Parser.make_fragment_context ~tag_name ~namespace () in
         let reader = Bytes.Reader.of_string test.input in
-        Parser.parse ~collect_errors:true ~fragment_context:context reader
+        Html5rw.Parser.parse ~collect_errors:true ~fragment_context:context reader
       | None ->
         let reader = Bytes.Reader.of_string test.input in
-        Parser.parse ~collect_errors:true reader
+        Html5rw.Parser.parse ~collect_errors:true reader
     in
-    let actual_tree = Dom.to_test_format (Parser.root result) in
+    let actual_tree = Html5rw.Dom.to_test_format (Html5rw.Parser.root result) in
     let expected = normalize_tree (strip_tree_prefix test.expected_tree) in
     let actual = normalize_tree (strip_tree_prefix actual_tree) in
-    let error_count = List.length (Parser.errors result) in
+    let error_count = List.length (Html5rw.Parser.errors result) in
     let expected_error_count = List.length test.expected_errors in
     (expected = actual, expected, actual, error_count, expected_error_count)
   with e ->

test/test_serializer.ml

···
 (* Test runner for html5lib-tests serializer tests *)
 
-module Dom = Html5rw_dom
+module Dom = Html5rw.Dom
 module Report = Test_report
 
 (* Extract values from JSON *)
···
   | EmptyTag of string * (string * string) list  (* name, attrs *)
   | TextNode of string
   | CommentNode of string
-  | DoctypeNode of Dom.node
+  | DoctypeNode of Html5rw.Dom.node
 
 type token_info = {
   token : token_type option;
···
 
     | "Doctype", [name_json] ->
       let name = json_string name_json in
-      let node = Dom.create_doctype ~name () in
+      let node = Html5rw.Dom.create_doctype ~name () in
       { token = Some (DoctypeNode node) }
 
     | "Doctype", [name_json; public_json] ->
       let name = json_string name_json in
       let public_id = json_string_opt public_json in
       let node = match public_id with
-       | Some pub -> Dom.create_doctype ~name ~public_id:pub ()
-       | None -> Dom.create_doctype ~name ()
+       | Some pub -> Html5rw.Dom.create_doctype ~name ~public_id:pub ()
+       | None -> Html5rw.Dom.create_doctype ~name ()
       in
       { token = Some (DoctypeNode node) }
 
···
       let public_id = json_string_opt public_json in
       let system_id = json_string_opt system_json in
       let node = match public_id, system_id with
-       | Some pub, Some sys -> Dom.create_doctype ~name ~public_id:pub ~system_id:sys ()
-       | Some pub, None -> Dom.create_doctype ~name ~public_id:pub ()
-       | None, Some sys -> Dom.create_doctype ~name ~system_id:sys ()
-       | None, None -> Dom.create_doctype ~name ()
+       | Some pub, Some sys -> Html5rw.Dom.create_doctype ~name ~public_id:pub ~system_id:sys ()
+       | Some pub, None -> Html5rw.Dom.create_doctype ~name ~public_id:pub ()
+       | None, Some sys -> Html5rw.Dom.create_doctype ~name ~system_id:sys ()
+       | None, None -> Html5rw.Dom.create_doctype ~name ()
       in
       { token = Some (DoctypeNode node) }
 

test/test_tokenizer.ml

···
 
 open Bytesrw
 
-module Tokenizer = Html5rw_tokenizer
+module Tokenizer = Html5rw.Tokenizer
 module Report = Test_report
 
 (* Token collector sink - collects all tokens into a list *)
 module TokenCollector = struct
   type t = {
-    mutable tokens : Tokenizer.Token.t list;
+    mutable tokens : Html5rw.Tokenizer.Token.t list;
   }
 
   let create () = { tokens = [] }
···
 
 (* Convert state name to State.t *)
 let state_of_string = function
-  | "Data state" -> Tokenizer.State.Data
-  | "PLAINTEXT state" -> Tokenizer.State.Plaintext
-  | "RCDATA state" -> Tokenizer.State.Rcdata
-  | "RAWTEXT state" -> Tokenizer.State.Rawtext
-  | "Script data state" -> Tokenizer.State.Script_data
-  | "CDATA section state" -> Tokenizer.State.Cdata_section
+  | "Data state" -> Html5rw.Tokenizer.State.Data
+  | "PLAINTEXT state" -> Html5rw.Tokenizer.State.Plaintext
+  | "RCDATA state" -> Html5rw.Tokenizer.State.Rcdata
+  | "RAWTEXT state" -> Html5rw.Tokenizer.State.Rawtext
+  | "Script data state" -> Html5rw.Tokenizer.State.Script_data
+  | "CDATA section state" -> Html5rw.Tokenizer.State.Cdata_section
   | s -> failwith ("Unknown state: " ^ s)
 
 (* Convert our token to test format for comparison *)
-let token_to_test_json (tok : Tokenizer.Token.t) : Jsont.json list =
+let token_to_test_json (tok : Html5rw.Tokenizer.Token.t) : Jsont.json list =
   let str s = Jsont.String (s, Jsont.Meta.none) in
   let arr l = Jsont.Array (l, Jsont.Meta.none) in
   match tok with
-  | Tokenizer.Token.Doctype { name; public_id; system_id; force_quirks } ->
+  | Html5rw.Tokenizer.Token.Doctype { name; public_id; system_id; force_quirks } ->
     let name_json = match name with
       | Some n -> str n
       | None -> Jsont.Null ((), Jsont.Meta.none)
···
     in
     let correctness = Jsont.Bool (not force_quirks, Jsont.Meta.none) in
     [arr [str "DOCTYPE"; name_json; public_json; system_json; correctness]]
-  | Tokenizer.Token.Tag { kind = Start; name; attrs; self_closing } ->
+  | Html5rw.Tokenizer.Token.Tag { kind = Start; name; attrs; self_closing } ->
     let attrs_obj = Jsont.Object (
       List.map (fun (n, v) -> ((n, Jsont.Meta.none), str v)) (List.rev attrs),
       Jsont.Meta.none
···
       [arr [str "StartTag"; str name; attrs_obj; Jsont.Bool (true, Jsont.Meta.none)]]
     else
       [arr [str "StartTag"; str name; attrs_obj]]
-  | Tokenizer.Token.Tag { kind = End; name; _ } ->
+  | Html5rw.Tokenizer.Token.Tag { kind = End; name; _ } ->
     [arr [str "EndTag"; str name]]
-  | Tokenizer.Token.Comment data ->
+  | Html5rw.Tokenizer.Token.Comment data ->
     [arr [str "Comment"; str data]]
-  | Tokenizer.Token.Character data ->
+  | Html5rw.Tokenizer.Token.Character data ->
     (* Split into individual characters for comparison - but actually
        the tests expect consecutive characters to be merged *)
     [arr [str "Character"; str data]]
-  | Tokenizer.Token.EOF -> []
+  | Html5rw.Tokenizer.Token.EOF -> []
 
 (* Compare JSON values for equality *)
 let rec json_equal a b =
···
 let merge_character_tokens tokens =
   let rec loop acc = function
     | [] -> List.rev acc
-    | Tokenizer.Token.Character s1 :: Tokenizer.Token.Character s2 :: rest ->
-      loop acc (Tokenizer.Token.Character (s1 ^ s2) :: rest)
+    | Html5rw.Tokenizer.Token.Character s1 :: Html5rw.Tokenizer.Token.Character s2 :: rest ->
+      loop acc (Html5rw.Tokenizer.Token.Character (s1 ^ s2) :: rest)
     | tok :: rest -> loop (tok :: acc) rest
   in
   loop [] tokens
···
   let input = if test.double_escaped then unescape_double test.input else test.input in
 
   let collector = TokenCollector.create () in
-  let tokenizer = Tokenizer.create (module TokenCollector) collector ~collect_errors:true ~xml_mode:test.xml_mode () in
+  let tokenizer = Html5rw.Tokenizer.create (module TokenCollector) collector ~collect_errors:true ~xml_mode:test.xml_mode () in
 
   (* Set initial state *)
-  Tokenizer.set_state tokenizer initial_state;
+  Html5rw.Tokenizer.set_state tokenizer initial_state;
 
   (* Set last start tag if specified *)
   (match test.last_start_tag with
-   | Some tag -> Tokenizer.set_last_start_tag tokenizer tag
+   | Some tag -> Html5rw.Tokenizer.set_last_start_tag tokenizer tag
    | None -> ());
 
   (* Run tokenizer *)
   let reader = Bytes.Reader.of_string input in
-  Tokenizer.run tokenizer (module TokenCollector) reader;
+  Html5rw.Tokenizer.run tokenizer (module TokenCollector) reader;
 
   (* Get results *)
   let tokens = merge_character_tokens (TokenCollector.get_tokens collector) in
···
     List.for_all2 json_equal actual_tokens expected
   in
 
-  let actual_error_count = List.length (Tokenizer.get_errors tokenizer) in
+  let actual_error_count = List.length (Html5rw.Tokenizer.get_errors tokenizer) in
   let errors_count_match = actual_error_count = test.expected_error_count in
 
   (tokens_match && errors_count_match, actual_tokens, expected, actual_error_count, test.expected_error_count)