validator

bin/html5check/dune

···
+(executable
+ (name html5check)
+ (public_name html5check)
+ (libraries html5_checker html5rw bytesrw cmdliner))

bin/html5check/html5check.ml

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+---------------------------------------------------------------------------*)
+
+(** html5check - HTML5 conformance checker CLI
+
+    Command line interface for validating HTML5 documents. *)
+
+open Cmdliner
+
+let version = "0.1.0"
+
+(** Exit codes *)
+module Exit_code = struct
+  let ok = Cmd.Exit.ok
+  let validation_errors = 1
+  let io_error = 2
+end
+
+(** Read input from file or stdin *)
+let read_input file =
+  try
+    let ic =
+      if file = "-" then stdin
+      else open_in file
+    in
+    let reader = Bytesrw.Bytes.Reader.of_in_channel ic in
+    Ok (reader, ic, file)
+  with
+  | Sys_error msg ->
+      Error (`Io_error (Printf.sprintf "Cannot read file '%s': %s" file msg))
+
+(** Format output based on the requested format *)
+let format_output format result =
+  match format with
+  | `Text -> Html5_checker.format_text result
+  | `Json -> Html5_checker.format_json result
+  | `Gnu -> Html5_checker.format_gnu result
+
+(** Run the validation *)
+let run format errors_only exit_zero quiet verbose file =
+  match read_input file with
+  | Error (`Io_error msg) ->
+      if not quiet then Printf.eprintf "Error: %s\n" msg;
+      Exit_code.io_error
+  | Ok (reader, ic, system_id) ->
+      (* Run validation *)
+      let result = Html5_checker.check ~system_id reader in
+
+      (* Close input if it's not stdin *)
+      if file <> "-" then close_in ic;
+
+      (* Get messages based on filtering *)
+      let messages =
+        if errors_only then Html5_checker.errors result
+        else Html5_checker.messages result
+      in
+
+      (* Output based on mode *)
+      if quiet then begin
+        (* Only show counts *)
+        let error_count = List.length (Html5_checker.errors result) in
+        let warning_count = List.length (Html5_checker.warnings result) in
+        if errors_only then
+          Printf.printf "%d error%s\n" error_count (if error_count = 1 then "" else "s")
+        else
+          Printf.printf "%d error%s, %d warning%s\n"
+            error_count (if error_count = 1 then "" else "s")
+            warning_count (if warning_count = 1 then "" else "s")
+      end else begin
+        (* Format and print messages *)
+        let output = format_output format result in
+        if output <> "" then print_string output;
+
+        (* Show summary if verbose *)
+        if verbose && messages <> [] then begin
+          let error_count = List.length (Html5_checker.errors result) in
+          let warning_count = List.length (Html5_checker.warnings result) in
+          Printf.eprintf "\nSummary: %d error%s, %d warning%s\n"
+            error_count (if error_count = 1 then "" else "s")
+            warning_count (if warning_count = 1 then "" else "s")
+        end
+      end;
+
+      (* Determine exit code *)
+      if exit_zero || not (Html5_checker.has_errors result) then
+        Exit_code.ok
+      else
+        Exit_code.validation_errors
+
+(** Command line argument definitions *)
+
+let format_arg =
+  let formats = [("text", `Text); ("json", `Json); ("gnu", `Gnu)] in
+  let doc =
+    "Output format. $(docv) must be one of $(b,text) (human-readable, default), \
+     $(b,json) (Nu validator compatible JSON), or $(b,gnu) (GNU-style for IDE integration)."
+  in
+  Arg.(value & opt (enum formats) `Text & info ["format"] ~docv:"FORMAT" ~doc)
+
+let errors_only_arg =
+  let doc = "Only show errors (suppress warnings)." in
+  Arg.(value & flag & info ["errors-only"] ~doc)
+
+let exit_zero_arg =
+  let doc =
+    "Always exit with status code 0, even if validation errors are found. \
+     Useful for CI pipelines where you want to collect validation results \
+     but not fail the build."
+  in
+  Arg.(value & flag & info ["exit-zero"] ~doc)
+
+let quiet_arg =
+  let doc = "Quiet mode - only show error and warning counts, no details." in
+  Arg.(value & flag & info ["q"; "quiet"] ~doc)
+
+let verbose_arg =
+  let doc = "Verbose mode - show additional information including summary." in
+  Arg.(value & flag & info ["v"; "verbose"] ~doc)
+
+let file_arg =
+  let doc =
+    "HTML file to validate. Use $(b,-) to read from standard input. \
+     If no file is specified, reads from stdin."
+  in
+  Arg.(value & pos 0 string "-" & info [] ~docv:"FILE" ~doc)
+
+let cmd =
+  let doc = "validate HTML5 documents for conformance" in
+  let man = [
+    `S Manpage.s_description;
+    `P "$(tname) validates HTML5 documents against the WHATWG HTML5 specification. \
+        It reports parse errors, structural validation issues, and conformance problems.";
+    `P "The validator checks for:";
+    `I ("Parse errors", "Malformed HTML syntax according to the WHATWG specification");
+    `I ("Content model violations", "Elements in invalid parent/child relationships");
+    `I ("Attribute errors", "Invalid or missing required attributes");
+    `I ("Structural issues", "Other conformance problems");
+    `S Manpage.s_options;
+    `S "OUTPUT FORMATS";
+    `P "The validator supports three output formats:";
+    `I ("$(b,text)", "Human-readable format showing file:line:col: severity: message");
+    `I ("$(b,json)", "JSON format compatible with the Nu Html Checker (v.Nu)");
+    `I ("$(b,gnu)", "GNU-style format for IDE integration (file:line:column: message)");
+    `S "EXIT STATUS";
+    `P "The validator exits with one of the following status codes:";
+    `I ("0", "No validation errors found (or --exit-zero was specified)");
+    `I ("1", "Validation errors were found");
+    `I ("2", "File not found or I/O error");
+    `S Manpage.s_examples;
+    `P "Validate a file:";
+    `Pre "    $(mname) index.html";
+    `P "Validate from stdin:";
+    `Pre "    cat page.html | $(mname) -";
+    `P "Show only errors in JSON format:";
+    `Pre "    $(mname) --format=json --errors-only page.html";
+    `P "Quiet mode for CI:";
+    `Pre "    $(mname) --quiet --exit-zero index.html";
+    `S Manpage.s_bugs;
+    `P "Report bugs at https://tangled.org/@anil.recoil.org/ocaml-html5rw/issues";
+  ] in
+  let info = Cmd.info "html5check" ~version ~doc ~man in
+  Cmd.v info Term.(const run $ format_arg $ errors_only_arg $ exit_zero_arg
+                              $ quiet_arg $ verbose_arg $ file_arg)
+
+let main () = Cmd.eval' cmd
+let () = Stdlib.exit (main ())

dune

···
-(data_only_dirs third_party)
+(vendored_dirs third_party)

dune-project

···
   (uutf (>= 1.0.0))
   (uuuu (>= 0.3.0))
   (odoc :with-doc)
-  (jsont (>= 0.2.0))))
+  (jsont (>= 0.2.0))
+  (cmdliner (>= 1.3.0))))

html5rw.opam

···
   "uuuu" {>= "0.3.0"}
   "odoc" {with-doc}
   "jsont" {>= "0.2.0"}
+  "cmdliner" {>= "1.3.0"}
 ]
 build: [
   ["dune" "subst"] {dev}

lib/html5_checker/checker.ml

···
+(** Base checker module for HTML5 conformance checking. *)
+
+module type S = sig
+  type state
+
+  val create : unit -> state
+  val reset : state -> unit
+
+  val start_element :
+    state ->
+    name:string ->
+    namespace:string option ->
+    attrs:(string * string) list ->
+    Message_collector.t ->
+    unit
+
+  val end_element :
+    state -> name:string -> namespace:string option -> Message_collector.t -> unit
+
+  val characters : state -> string -> Message_collector.t -> unit
+  val end_document : state -> Message_collector.t -> unit
+end
+
+type t = (module S)
+
+(** No-operation checker implementation. *)
+module Noop = struct
+  type state = unit
+
+  let create () = ()
+  let reset () = ()
+
+  let start_element () ~name:_ ~namespace:_ ~attrs:_ _ = ()
+  let end_element () ~name:_ ~namespace:_ _ = ()
+  let characters () _ _ = ()
+  let end_document () _ = ()
+end
+
+let noop () = (module Noop : S)

lib/html5_checker/checker.mli

···
+(** Base checker module for HTML5 conformance checking.
+
+    This module provides the core checker abstraction used throughout the
+    html5_checker library. A checker validates HTML5 documents by observing
+    DOM tree traversal events and emitting validation messages.
+
+    {2 Design Overview}
+
+    Checkers follow a SAX-like event model where they receive notifications
+    about elements, text, and document boundaries as a DOM tree is traversed.
+    This design allows for:
+
+    - {b Stateful validation}: Each checker maintains its own state across
+      multiple events
+    - {b Composability}: Multiple checkers can validate the same document
+      simultaneously
+    - {b Efficiency}: DOM traversal happens once regardless of checker count
+
+    {2 Checker Lifecycle}
+
+    A checker progresses through these phases:
+
+    1. {b Creation}: Initialize with {!create} to set up initial state
+    2. {b Traversal}: Receive {!start_element}, {!characters}, and
+       {!end_element} events as the DOM is walked
+    3. {b Completion}: Finalize validation with {!end_document}
+    4. {b Reset} (optional): Return to initial state with {!reset}
+
+    {3 Event Sequence}
+
+    For a document like [<p>Hello <b>world</b></p>], the event sequence is:
+
+    {v
+    start_element "p"
+      characters "Hello "
+      start_element "b"
+        characters "world"
+      end_element "b"
+    end_element "p"
+    end_document
+    v}
+
+    {2 First-Class Modules}
+
+    Checkers are represented as first-class modules implementing the {!S}
+    signature. This allows:
+
+    - Dynamic checker registration and discovery
+    - Heterogeneous collections of checkers
+    - Checker selection at runtime based on validation requirements
+
+    @see <https://v2.ocaml.org/manual/firstclassmodules.html>
+         OCaml manual: First-class modules
+*)
+
+(** {1 Module Signature} *)
+
+(** The signature that all checker modules must implement.
+
+    A checker module maintains validation state and receives notifications
+    about DOM tree traversal events. *)
+module type S = sig
+  (** The type of checker state.
+
+      This is an abstract type that holds the checker's internal validation
+      state. Different checkers will have different state representations
+      depending on what they need to track during validation. *)
+  type state
+
+  (** {1 Lifecycle Operations} *)
+
+  val create : unit -> state
+  (** [create ()] initializes a new checker state.
+
+      This function sets up the initial state needed for validation,
+      such as empty stacks for context tracking, counters, or lookup
+      tables. *)
+
+  val reset : state -> unit
+  (** [reset state] resets the checker to its initial state.
+
+      This allows reusing a checker for multiple documents without
+      reallocating. After reset, the checker behaves as if freshly
+      created with {!create}. *)
+
+  (** {1 DOM Traversal Events} *)
+
+  val start_element :
+    state ->
+    name:string ->
+    namespace:string option ->
+    attrs:(string * string) list ->
+    Message_collector.t ->
+    unit
+  (** [start_element state ~name ~namespace ~attrs collector] is called when
+      entering an element during DOM traversal.
+
+      @param state The checker state
+      @param name The element tag name (e.g., "div", "p", "span")
+      @param namespace The element namespace ([None] for HTML, [Some "svg"]
+             for SVG, [Some "mathml"] for MathML)
+      @param attrs The element's attributes as [(name, value)] pairs
+      @param collector The message collector for emitting validation messages
+
+      This is where checkers can validate:
+      - Whether the element is allowed in the current context
+      - Whether required attributes are present
+      - Whether attribute values are valid
+      - Whether the element opens a new validation context *)
+
+  val end_element :
+    state -> name:string -> namespace:string option -> Message_collector.t -> unit
+  (** [end_element state ~name ~namespace collector] is called when exiting
+      an element during DOM traversal.
+
+      @param state The checker state
+      @param name The element tag name
+      @param namespace The element namespace
+      @param collector The message collector for emitting validation messages
+
+      This is where checkers can:
+      - Pop validation contexts from stacks
+      - Validate that required child elements were present
+      - Emit messages about element-scoped validation rules *)
+
+  val characters : state -> string -> Message_collector.t -> unit
+  (** [characters state text collector] is called when text content is
+      encountered during DOM traversal.
+
+      @param state The checker state
+      @param text The text content
+      @param collector The message collector for emitting validation messages
+
+      This is where checkers can validate:
+      - Whether text is allowed in the current context
+      - Whether text content follows specific patterns
+      - Whether text matches expected formats *)
+
+  val end_document : state -> Message_collector.t -> unit
+  (** [end_document state collector] is called after the entire DOM tree has
+      been traversed.
+
+      @param state The checker state
+      @param collector The message collector for emitting validation messages
+
+      This is where checkers can:
+      - Emit messages about missing required elements
+      - Validate document-level constraints
+      - Check that all opened contexts were properly closed
+      - Report any accumulated validation failures *)
+end
+
+(** {1 Checker Values} *)
+
+(** The type of a checker value.
+
+    This is a packed first-class module containing both the checker
+    implementation and its state. It enables storing heterogeneous
+    checkers in collections and passing them around dynamically. *)
+type t = (module S)
+
+(** {1 Built-in Checkers} *)
+
+val noop : unit -> t
+(** [noop ()] creates a no-operation checker that performs no validation.
+
+    This checker ignores all events and never emits messages. It is useful:
+    - As a placeholder in checker registries
+    - For testing checker infrastructure
+    - As a base for building new checkers
+
+    {b Example:}
+    {[
+      let checker = noop () in
+      (* Does nothing when walked over a DOM tree *)
+    ]}
+*)

lib/html5_checker/checker_registry.ml

···
+(** Registry for HTML5 conformance checkers. *)
+
+type t = (string, Checker.t) Hashtbl.t
+
+let create () = Hashtbl.create 16
+
+let default () =
+  (* In Phase 1, return an empty registry.
+     Built-in checkers will be added in later phases. *)
+  create ()
+
+let register registry name checker = Hashtbl.replace registry name checker
+
+let unregister registry name = Hashtbl.remove registry name
+
+let get registry name = Hashtbl.find_opt registry name
+
+let list_names registry =
+  Hashtbl.to_seq_keys registry |> List.of_seq
+
+let all registry =
+  Hashtbl.to_seq_values registry |> List.of_seq

lib/html5_checker/checker_registry.mli

···
+(** Registry for HTML5 conformance checkers.
+
+    This module provides a dynamic registry for managing collections of
+    checkers. It enables:
+
+    - {b Registration}: Add checkers under descriptive names
+    - {b Discovery}: Retrieve checkers by name or list all available ones
+    - {b Lifecycle management}: Register and unregister checkers at runtime
+    - {b Defaults}: Access a pre-configured set of built-in checkers
+
+    {2 Design Rationale}
+
+    The registry pattern separates checker implementation from checker usage.
+    Applications can:
+
+    1. Query available checkers to present options to users
+    2. Select specific checkers based on validation requirements
+    3. Add custom checkers without modifying library code
+    4. Share checker configurations across validation runs
+
+    {2 Usage Pattern}
+
+    {[
+      (* Start with default checkers *)
+      let reg = default () in
+
+      (* Add a custom checker *)
+      let my_checker = (module MyChecker : Checker.S) in
+      register reg "my-custom-check" my_checker;
+
+      (* List all available checkers *)
+      let names = list_names reg in
+      List.iter (Printf.printf "Available: %s\n") names;
+
+      (* Retrieve a specific checker *)
+      match get reg "my-custom-check" with
+      | Some checker -> (* Use the checker *)
+      | None -> (* Not found *)
+
+      (* Get all checkers for validation *)
+      let all_checkers = all reg in
+      (* Pass to dom_walker *)
+    ]}
+
+    {2 Thread Safety}
+
+    This registry is not thread-safe. If shared across threads, external
+    synchronization is required. *)
+
+(** {1 Types} *)
+
+(** The type of a checker registry.
+
+    This is an opaque type representing a mutable collection of named
+    checkers. Internally implemented as a hash table for efficient lookups. *)
+type t
+
+(** {1 Creation} *)
+
+val create : unit -> t
+(** [create ()] creates a new empty checker registry.
+
+    Use this when you want to build a custom set of checkers from scratch,
+    without any defaults. *)
+
+val default : unit -> t
+(** [default ()] creates a registry with built-in checkers.
+
+    The default registry is initially empty but serves as a starting point
+    for adding standard validation checkers in future phases.
+
+    Built-in checkers will include:
+    - Document structure validation
+    - Attribute validation
+    - Content model checking
+    - Accessibility checks
+
+    Note: In Phase 1, the default registry is empty. Built-in checkers
+    will be added in subsequent phases. *)
+
+(** {1 Registration} *)
+
+val register : t -> string -> Checker.t -> unit
+(** [register registry name checker] adds a checker to the registry.
+
+    @param registry The registry to add to
+    @param name A unique identifier for the checker (e.g., "obsolete-elements",
+           "required-attributes")
+    @param checker The checker implementation
+
+    If a checker with the same name already exists, it is replaced.
+
+    {b Example:}
+    {[
+      let reg = create () in
+      let checker = (module MyChecker : Checker.S) in
+      register reg "my-check" checker
+    ]} *)
+
+val unregister : t -> string -> unit
+(** [unregister registry name] removes a checker from the registry.
+
+    @param registry The registry to remove from
+    @param name The checker name
+
+    If no checker with the given name exists, this is a no-op. *)
+
+(** {1 Retrieval} *)
+
+val get : t -> string -> Checker.t option
+(** [get registry name] retrieves a checker by name.
+
+    @param registry The registry to search
+    @param name The checker name
+    @return [Some checker] if found, [None] otherwise
+
+    {b Example:}
+    {[
+      match get reg "obsolete-elements" with
+      | Some checker -> (* Use checker *)
+      | None -> (* Checker not registered *)
+    ]} *)
+
+val list_names : t -> string list
+(** [list_names registry] returns all registered checker names.
+
+    @param registry The registry to query
+    @return A list of all checker names in arbitrary order
+
+    This is useful for:
+    - Displaying available checkers to users
+    - Debugging registry contents
+    - Iterating over specific subsets of checkers
+
+    {b Example:}
+    {[
+      let names = list_names reg in
+      Printf.printf "Available checkers: %s\n"
+        (String.concat ", " names)
+    ]} *)
+
+val all : t -> Checker.t list
+(** [all registry] returns all registered checkers.
+
+    @param registry The registry to query
+    @return A list of all checkers in arbitrary order
+
+    This is the primary way to retrieve checkers for validation.
+    Pass the result to {!Dom_walker.walk_all} to run all registered
+    checkers on a DOM tree.
+
+    {b Example:}
+    {[
+      let checkers = all reg in
+      Dom_walker.walk_all checkers collector dom
+    ]} *)

lib/html5_checker/content_model/attr_spec.ml

···
+type t = {
+  name : string;
+  required : bool;
+  datatype : string option;
+  enum_values : string list option;
+  deprecated : bool;
+}
+
+let make name ?(required = false) ?datatype ?enum_values ?(deprecated = false) () =
+  { name; required; datatype; enum_values; deprecated }
+
+let pp fmt t =
+  Format.fprintf fmt "@[<v 2>{ name = %S;@ required = %b;@ " t.name t.required;
+  (match t.datatype with
+  | None -> Format.fprintf fmt "datatype = None;@ "
+  | Some dt -> Format.fprintf fmt "datatype = Some %S;@ " dt);
+  (match t.enum_values with
+  | None -> Format.fprintf fmt "enum_values = None;@ "
+  | Some vals ->
+      Format.fprintf fmt "enum_values = Some [%a];@ "
+        (Format.pp_print_list
+           ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+           (fun fmt s -> Format.fprintf fmt "%S" s))
+        vals);
+  Format.fprintf fmt "deprecated = %b }@]" t.deprecated

lib/html5_checker/content_model/attr_spec.mli

···
+(** HTML5 attribute specifications. *)
+
+type t = {
+  name : string;
+  required : bool;
+  datatype : string option;  (** Datatype name for validation *)
+  enum_values : string list option;  (** Allowed values if enumerated *)
+  deprecated : bool;
+}
+
+val make :
+  string ->
+  ?required:bool ->
+  ?datatype:string ->
+  ?enum_values:string list ->
+  ?deprecated:bool ->
+  unit ->
+  t
+
+val pp : Format.formatter -> t -> unit

lib/html5_checker/content_model/attribute_spec.ml

···
+type requirement = Required | Optional
+
+type t = {
+  name : string;
+  requirement : requirement;
+  datatype : string option;
+  description : string;
+}
+
+let create ~name ?(requirement = Optional) ?datatype ~description () =
+  { name; requirement; datatype; description }
+
+let requirement_to_string = function
+  | Required -> "required"
+  | Optional -> "optional"
+
+let to_string t =
+  let req = requirement_to_string t.requirement in
+  let dt =
+    match t.datatype with
+    | None -> ""
+    | Some d -> Printf.sprintf " (%s)" d
+  in
+  Printf.sprintf "%s [%s]%s: %s" t.name req dt t.description
+
+let pp fmt t = Format.fprintf fmt "%s" (to_string t)

lib/html5_checker/content_model/attribute_spec.mli

···
+(** HTML5 attribute specifications.
+
+    Defines attribute requirements and constraints for HTML5 elements.
+    See https://html.spec.whatwg.org/multipage/indices.html#attributes-3 *)
+
+type requirement =
+  | Required  (** Attribute must be present *)
+  | Optional  (** Attribute may be present *)
+
+type t = {
+  name : string;
+  (** Attribute name *)
+
+  requirement : requirement;
+  (** Whether attribute is required or optional *)
+
+  datatype : string option;
+  (** Datatype validator name (e.g., "url", "integer", "boolean") *)
+
+  description : string;
+  (** Human-readable description *)
+}
+
+val create :
+  name:string ->
+  ?requirement:requirement ->
+  ?datatype:string ->
+  description:string ->
+  unit ->
+  t
+(** Create an attribute specification.
+
+    @param name Attribute name
+    @param requirement Whether required or optional (default: Optional)
+    @param datatype Datatype validator name
+    @param description Human-readable description *)
+
+val to_string : t -> string
+
+val pp : Format.formatter -> t -> unit

lib/html5_checker/content_model/category.ml

···
+type t =
+  | Metadata
+  | Flow
+  | Sectioning
+  | Heading
+  | Phrasing
+  | Embedded
+  | Interactive
+  | Palpable
+  | Script_supporting
+  | Form_associated
+  | Listed
+  | Labelable
+  | Submittable
+  | Resettable
+  | Autocapitalize_inheriting
+  | Transparent
+
+let to_string = function
+  | Metadata -> "metadata"
+  | Flow -> "flow"
+  | Sectioning -> "sectioning"
+  | Heading -> "heading"
+  | Phrasing -> "phrasing"
+  | Embedded -> "embedded"
+  | Interactive -> "interactive"
+  | Palpable -> "palpable"
+  | Script_supporting -> "script-supporting"
+  | Form_associated -> "form-associated"
+  | Listed -> "listed"
+  | Labelable -> "labelable"
+  | Submittable -> "submittable"
+  | Resettable -> "resettable"
+  | Autocapitalize_inheriting -> "autocapitalize-inheriting"
+  | Transparent -> "transparent"
+
+let compare (a : t) (b : t) = Stdlib.compare a b
+
+let equal (a : t) (b : t) = a = b

lib/html5_checker/content_model/category.mli

···
+(** HTML5 content categories.
+
+    This module defines the content categories used in HTML5 to classify elements
+    based on their characteristics and allowed contexts. Elements can belong to
+    multiple categories.
+
+    @see <https://html.spec.whatwg.org/multipage/dom.html#content-models> WHATWG HTML Specification *)
+
+(** Content category type. *)
+type t =
+  | Metadata
+      (** Metadata content sets up the presentation or behavior of the rest of
+          the content, or sets up the relationship of the document with other
+          documents, or conveys other "out of band" information. *)
+  | Flow
+      (** Most elements that are used in the body of documents and applications
+          are categorized as flow content. *)
+  | Sectioning
+      (** Sectioning content is content that defines the scope of headings and
+          footers. *)
+  | Heading
+      (** Heading content defines the heading of a section (whether explicitly
+          marked up using sectioning content elements, or implied by the heading
+          content itself). *)
+  | Phrasing
+      (** Phrasing content is the text of the document, as well as elements that
+          mark up that text at the intra-paragraph level. *)
+  | Embedded
+      (** Embedded content is content that imports another resource into the
+          document, or content from another vocabulary that is inserted into the
+          document. *)
+  | Interactive
+      (** Interactive content is content that is specifically intended for user
+          interaction. *)
+  | Palpable
+      (** As a general rule, elements whose content model allows any flow content
+          or phrasing content should have at least one node in its contents that
+          is palpable content and that does not have the hidden attribute specified. *)
+  | Script_supporting
+      (** Script-supporting elements are those that do not represent anything
+          themselves (i.e., they are not rendered), but are used to support scripts. *)
+  | Form_associated
+      (** Form-associated elements can have a form owner. *)
+  | Listed
+      (** Listed form-associated elements have a form attribute that can point
+          to a form element. *)
+  | Labelable
+      (** Labelable form-associated elements can be associated with label elements. *)
+  | Submittable
+      (** Submittable form-associated elements can be used for constructing the
+          entry list when a form element is submitted. *)
+  | Resettable
+      (** Resettable form-associated elements are affected when a form element
+          is reset. *)
+  | Autocapitalize_inheriting
+      (** Some elements inherit the autocapitalize attribute from their form owner. *)
+  | Transparent
+      (** Transparent content models adopt the content model of their parent
+          element. *)
+
+(** {1 Predicates} *)
+
+val to_string : t -> string
+(** [to_string category] returns a string representation of the category. *)
+
+val compare : t -> t -> int
+(** [compare c1 c2] compares two categories for ordering. *)
+
+val equal : t -> t -> bool
+(** [equal c1 c2] returns [true] if the categories are equal. *)

lib/html5_checker/content_model/content_category.ml

···
+type t =
+  | Metadata
+  | Flow
+  | Sectioning
+  | Heading
+  | Phrasing
+  | Embedded
+  | Interactive
+  | Palpable
+  | Script_supporting
+
+let to_string = function
+  | Metadata -> "metadata"
+  | Flow -> "flow"
+  | Sectioning -> "sectioning"
+  | Heading -> "heading"
+  | Phrasing -> "phrasing"
+  | Embedded -> "embedded"
+  | Interactive -> "interactive"
+  | Palpable -> "palpable"
+  | Script_supporting -> "script-supporting"
+
+let of_string = function
+  | "metadata" -> Some Metadata
+  | "flow" -> Some Flow
+  | "sectioning" -> Some Sectioning
+  | "heading" -> Some Heading
+  | "phrasing" -> Some Phrasing
+  | "embedded" -> Some Embedded
+  | "interactive" -> Some Interactive
+  | "palpable" -> Some Palpable
+  | "script-supporting" -> Some Script_supporting
+  | _ -> None
+
+let pp fmt t = Format.fprintf fmt "%s" (to_string t)
+
+let all =
+  [
+    Metadata;
+    Flow;
+    Sectioning;
+    Heading;
+    Phrasing;
+    Embedded;
+    Interactive;
+    Palpable;
+    Script_supporting;
+  ]

lib/html5_checker/content_model/content_category.mli

···
+(** HTML5 content categories.
+
+    Elements are categorized for determining valid parent-child relationships.
+    See https://html.spec.whatwg.org/multipage/dom.html#content-models *)
+
+type t =
+  | Metadata  (** head, title, meta, link, style, script, noscript, base *)
+  | Flow  (** Most body elements *)
+  | Sectioning  (** article, aside, nav, section *)
+  | Heading  (** h1-h6, hgroup *)
+  | Phrasing  (** Inline elements: a, em, strong, span, etc. *)
+  | Embedded  (** img, video, audio, canvas, iframe, embed, object *)
+  | Interactive  (** a (with href), button, input, select, textarea, details *)
+  | Palpable  (** Elements with renderable content *)
+  | Script_supporting  (** script, template *)
+
+val to_string : t -> string
+
+val of_string : string -> t option
+
+val pp : Format.formatter -> t -> unit
+
+val all : t list

lib/html5_checker/content_model/content_checker.ml

···
+type element_context = {
+  name : string;
+  spec : Element_spec.t;
+  children_count : int;
+}
+
+type state = {
+  registry : Element_registry.t;
+  mutable ancestor_stack : element_context list;
+}
+
+let create_with_registry ?(registry = Element_registry.default ()) _collector =
+  { registry; ancestor_stack = [] }
+
+let create () = create_with_registry (Message_collector.create ())
+
+let reset state =
+  state.ancestor_stack <- []
+
+(* Check if an element name matches a content model *)
+let rec matches_content_model registry element_name content_model =
+  match content_model with
+  | Content_model.Nothing -> false
+  | Content_model.Text -> false (* Text, not element *)
+  | Content_model.Transparent -> true (* Inherits parent, allow for now *)
+  | Content_model.Categories cats -> (
+      match Element_registry.get registry element_name with
+      | None -> false
+      | Some spec ->
+          List.exists (fun cat -> Element_spec.has_category spec cat) cats)
+  | Content_model.Elements names ->
+      List.mem (String.lowercase_ascii element_name)
+        (List.map String.lowercase_ascii names)
+  | Content_model.Mixed cats -> (
+      match Element_registry.get registry element_name with
+      | None -> false
+      | Some spec ->
+          List.exists (fun cat -> Element_spec.has_category spec cat) cats)
+  | Content_model.One_or_more model -> matches_content_model registry element_name model
+  | Content_model.Zero_or_more model -> matches_content_model registry element_name model
+  | Content_model.Optional model -> matches_content_model registry element_name model
+  | Content_model.Sequence models ->
+      (* For sequences, allow any of the models for now (simplified) *)
+      List.exists (matches_content_model registry element_name) models
+  | Content_model.Choice models ->
+      List.exists (matches_content_model registry element_name) models
+  | Content_model.Except (model, excluded_cats) -> (
+      match Element_registry.get registry element_name with
+      | None -> matches_content_model registry element_name model
+      | Some spec ->
+          matches_content_model registry element_name model
+          && not (List.exists (fun cat -> Element_spec.has_category spec cat) excluded_cats))
+
+(* Check if text is allowed in a content model *)
+let rec allows_text content_model =
+  match content_model with
+  | Content_model.Nothing -> false
+  | Content_model.Text -> true
+  | Content_model.Transparent -> true (* Inherits parent *)
+  | Content_model.Categories _ -> false (* Elements only *)
+  | Content_model.Elements _ -> false (* Specific elements only *)
+  | Content_model.Mixed _ -> true (* Text + elements *)
+  | Content_model.One_or_more model -> allows_text model
+  | Content_model.Zero_or_more model -> allows_text model
+  | Content_model.Optional model -> allows_text model
+  | Content_model.Sequence models -> List.exists allows_text models
+  | Content_model.Choice models -> List.exists allows_text models
+  | Content_model.Except (model, _) -> allows_text model
+
+(* Check for prohibited ancestors *)
+let check_prohibited_ancestors state name spec collector =
+  List.iter
+    (fun prohibited ->
+      if List.exists (fun ctx -> String.equal ctx.name prohibited) state.ancestor_stack then
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf "Element '%s' cannot be nested inside '%s'" name prohibited)
+          ~code:"prohibited-ancestor"
+          ~element:name
+          ())
+    spec.Element_spec.prohibited_ancestors
+
+(* Validate that a child element is allowed *)
+let validate_child_element state child_name collector =
+  match state.ancestor_stack with
+  | [] ->
+      (* Root level - only html allowed *)
+      if not (String.equal (String.lowercase_ascii child_name) "html") then
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf "Element '%s' not allowed at document root (only 'html' allowed)" child_name)
+          ~code:"invalid-root-element"
+          ~element:child_name
+          ()
+  | parent :: _ ->
+      let content_model = parent.spec.Element_spec.content_model in
+      if not (matches_content_model state.registry child_name content_model) then
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf
+              "Element '%s' not allowed as child of '%s' (content model: %s)"
+              child_name
+              parent.name
+              (Content_model.to_string content_model))
+          ~code:"invalid-child-element"
+          ~element:child_name
+          ()
+
+let start_element state ~name ~namespace:_ ~attrs:_ collector =
+  (* Look up element specification *)
+  let spec_opt = Element_registry.get state.registry name in
+
+  match spec_opt with
+  | None ->
+      (* Unknown element - emit warning *)
+      Message_collector.add_warning collector
+        ~message:(Printf.sprintf "Unknown element '%s'" name)
+        ~code:"unknown-element"
+        ~element:name
+        ()
+  | Some spec ->
+      (* Check prohibited ancestors *)
+      check_prohibited_ancestors state name spec collector;
+
+      (* Validate this element is allowed as child of parent *)
+      validate_child_element state name collector;
+
+      (* Push element context onto stack *)
+      let context = { name; spec; children_count = 0 } in
+      state.ancestor_stack <- context :: state.ancestor_stack
+
+let end_element state ~name ~namespace:_ collector =
+  match state.ancestor_stack with
+  | [] ->
+      (* Unmatched closing tag *)
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf "Unmatched closing tag '%s'" name)
+        ~code:"unmatched-closing-tag"
+        ~element:name
+        ()
+  | context :: rest ->
+      if not (String.equal context.name name) then
+        (* Mismatched tag *)
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf "Expected closing tag '%s' but got '%s'" context.name name)
+          ~code:"mismatched-closing-tag"
+          ~element:name
+          ()
+      else (
+        (* Check if void element has children *)
+        if Element_spec.is_void context.spec && context.children_count > 0 then
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Void element '%s' must not have children" name)
+            ~code:"void-element-has-children"
+            ~element:name
+            ();
+
+        (* Pop stack *)
+        state.ancestor_stack <- rest;
+
+        (* If there's a parent, increment its child count *)
+        match rest with
+        | [] -> ()
+        | parent :: rest_tail ->
+            let updated_parent = { parent with children_count = parent.children_count + 1 } in
+            state.ancestor_stack <- updated_parent :: rest_tail)
+
+let characters state text collector =
+  (* Check if text is allowed in current context *)
+  match state.ancestor_stack with
+  | [] ->
+      (* Text at root level - only whitespace allowed *)
+      if not (String.trim text = "") then
+        Message_collector.add_error collector
+          ~message:"Text content not allowed at document root"
+          ~code:"text-at-root"
+          ()
+  | parent :: rest ->
+      let content_model = parent.spec.Element_spec.content_model in
+      if not (allows_text content_model) then
+        (* Only report if non-whitespace text *)
+        if not (String.trim text = "") then
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf
+                "Text content not allowed in '%s' (content model: %s)"
+                parent.name
+                (Content_model.to_string content_model))
+            ~code:"text-not-allowed"
+            ~element:parent.name
+            ()
+      else (
+        (* Text is allowed, increment child count *)
+        let updated_parent = { parent with children_count = parent.children_count + 1 } in
+        state.ancestor_stack <- updated_parent :: rest)
+
+let end_document state collector =
+  (* Check for unclosed elements *)
+  List.iter
+    (fun context ->
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf "Unclosed element '%s'" context.name)
+        ~code:"unclosed-element"
+        ~element:context.name
+        ())
+    state.ancestor_stack
+
+(* Package as first-class module *)
+let checker =
+  (module struct
+    type nonrec state = state
+
+    let create = create
+    let reset = reset
+    let start_element = start_element
+    let end_element = end_element
+    let characters = characters
+    let end_document = end_document
+  end : Checker.S)

lib/html5_checker/content_model/content_checker.mli

···
+(** Content model checker.
+
+    Validates that HTML elements conform to their content model specifications.
+
+    The content model checker performs structural validation of HTML documents
+    by ensuring that:
+
+    - Element children match the element's declared content model
+    - No prohibited ancestor relationships exist (e.g., no [<a>] inside [<a>])
+    - Void elements contain no children
+    - Required children are present where mandated
+
+    {2 Content Model Validation}
+
+    The checker validates content models by:
+
+    1. Looking up the element specification in the registry
+    2. Checking each child element or text node against the content model
+    3. Tracking the ancestor stack to detect prohibited relationships
+    4. Emitting appropriate errors or warnings for violations
+
+    {2 Usage Example}
+
+    {[
+      let checker = Content_checker.create (Message_collector.create ()) in
+      let module C = (val checker : Checker.S) in
+      let state = C.create () in
+
+      (* Walk the DOM tree *)
+      C.start_element state ~name:"div" ~namespace:None ~attrs:[] collector;
+      C.characters state "Hello, world!" collector;
+      C.end_element state ~name:"div" ~namespace:None collector;
+      C.end_document state collector
+    ]}
+*)
+
+(** Include the standard checker signature. *)
+include Checker.S
+
+(** {1 Creation} *)
+
+val create_with_registry : ?registry:Element_registry.t -> Message_collector.t -> state
+(** [create_with_registry ?registry collector] creates a content checker with an
+    optional custom element registry.
+
+    If no registry is provided, uses {!Element_registry.default}.
+
+    @param registry Custom element registry (defaults to standard HTML5 elements)
+    @param collector Message collector for validation messages *)
+
+(** {1 First-Class Module} *)
+
+val checker : Checker.t
+(** [checker] is the content checker packaged as a first-class module.
+
+    This allows the content checker to be used in checker registries and
+    other contexts that work with heterogeneous checker collections. *)

lib/html5_checker/content_model/content_model.ml

···
+type t =
+  | Nothing
+  | Text
+  | Transparent
+  | Categories of Content_category.t list
+  | Elements of string list
+  | Mixed of Content_category.t list
+  | One_or_more of t
+  | Zero_or_more of t
+  | Optional of t
+  | Sequence of t list
+  | Choice of t list
+  | Except of t * Content_category.t list
+
+let rec pp fmt = function
+  | Nothing -> Format.fprintf fmt "Nothing"
+  | Text -> Format.fprintf fmt "Text"
+  | Transparent -> Format.fprintf fmt "Transparent"
+  | Categories cats ->
+      Format.fprintf fmt "Categories [%a]"
+        (Format.pp_print_list
+           ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+           Content_category.pp)
+        cats
+  | Elements elems ->
+      Format.fprintf fmt "Elements [%a]"
+        (Format.pp_print_list
+           ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+           Format.pp_print_string)
+        elems
+  | Mixed cats ->
+      Format.fprintf fmt "Mixed [%a]"
+        (Format.pp_print_list
+           ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+           Content_category.pp)
+        cats
+  | One_or_more t -> Format.fprintf fmt "One_or_more (%a)" pp t
+  | Zero_or_more t -> Format.fprintf fmt "Zero_or_more (%a)" pp t
+  | Optional t -> Format.fprintf fmt "Optional (%a)" pp t
+  | Sequence ts ->
+      Format.fprintf fmt "Sequence [%a]"
+        (Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ") pp)
+        ts
+  | Choice ts ->
+      Format.fprintf fmt "Choice [%a]"
+        (Format.pp_print_list ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ") pp)
+        ts
+  | Except (t, cats) ->
+      Format.fprintf fmt "Except (%a, [%a])" pp t
+        (Format.pp_print_list
+           ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+           Content_category.pp)
+        cats
+
+let to_string t =
+  let buf = Buffer.create 256 in
+  let fmt = Format.formatter_of_buffer buf in
+  pp fmt t;
+  Format.pp_print_flush fmt ();
+  Buffer.contents buf

lib/html5_checker/content_model/content_model.mli

···
+(** HTML5 element content models.
+
+    Defines what children an element can contain. *)
+
+type t =
+  | Nothing  (** No children allowed (void elements) *)
+  | Text  (** Text only (no elements) *)
+  | Transparent  (** Inherits parent's content model *)
+  | Categories of Content_category.t list  (** Elements from categories *)
+  | Elements of string list  (** Specific elements only *)
+  | Mixed of Content_category.t list  (** Text + elements from categories *)
+  | One_or_more of t  (** At least one child matching *)
+  | Zero_or_more of t  (** Any number of children matching *)
+  | Optional of t  (** Zero or one child matching *)
+  | Sequence of t list  (** Ordered sequence *)
+  | Choice of t list  (** Any one of *)
+  | Except of t * Content_category.t list  (** t except categories *)
+
+val pp : Format.formatter -> t -> unit
+
+val to_string : t -> string

lib/html5_checker/content_model/element_registry.ml

···
+type t = (string, Element_spec.t) Hashtbl.t
+
+let create () = Hashtbl.create 128
+
+let register registry spec =
+  let name = String.lowercase_ascii spec.Element_spec.name in
+  Hashtbl.replace registry name spec
+
+let get registry name =
+  let name = String.lowercase_ascii name in
+  Hashtbl.find_opt registry name
+
+let list_names registry =
+  Hashtbl.to_seq_keys registry
+  |> List.of_seq
+  |> List.sort String.compare
+
+let all registry =
+  Hashtbl.to_seq_values registry
+  |> List.of_seq
+
+let default () =
+  let registry = create () in
+
+  (* Register document structure elements *)
+  List.iter (register registry) Elements_document.all;
+
+  (* Register text-level elements *)
+  List.iter (register registry) Elements_text.all;
+
+  (* Register form elements *)
+  List.iter (register registry) Elements_form.all;
+
+  (* Register embedded content elements *)
+  List.iter (register registry) Elements_embedded.all;
+
+  (* Register table elements *)
+  List.iter (register registry) Elements_table.all;
+
+  (* Register interactive elements *)
+  List.iter (register registry) Elements_interactive.all;
+
+  registry

lib/html5_checker/content_model/element_registry.mli

···
+(** Registry for HTML5 element specifications.
+
+    Provides fast lookup of element specs by name. *)
+
+(** The type of an element registry. *)
+type t
+
+(** {1 Creation and Modification} *)
+
+val create : unit -> t
+(** [create ()] creates a new empty element registry. *)
+
+val register : t -> Element_spec.t -> unit
+(** [register registry spec] adds an element specification to the registry.
+
+    If an element with the same name already exists, it is replaced. *)
+
+(** {1 Lookup} *)
+
+val get : t -> string -> Element_spec.t option
+(** [get registry name] looks up an element specification by tag name.
+
+    Returns [None] if the element is not registered. Tag names are
+    case-insensitive. *)
+
+val list_names : t -> string list
+(** [list_names registry] returns a sorted list of all registered element names. *)
+
+val all : t -> Element_spec.t list
+(** [all registry] returns all registered element specifications. *)
+
+(** {1 Default Registry} *)
+
+val default : unit -> t
+(** [default ()] creates a registry pre-populated with all standard HTML5 elements.
+
+    The registry includes elements from:
+    - {!Elements_document} - Document structure and sectioning
+    - {!Elements_text} - Text-level semantics
+    - {!Elements_form} - Forms and input controls
+    - {!Elements_embedded} - Embedded content
+    - {!Elements_table} - Tables
+    - {!Elements_interactive} - Interactive elements *)

lib/html5_checker/content_model/element_spec.ml

···
+type t = {
+  name : string;
+  void : bool;
+  categories : Content_category.t list;
+  content_model : Content_model.t;
+  permitted_parents : string list option;
+  prohibited_ancestors : string list;
+  tag_omission : bool;
+  attrs : Attr_spec.t list;
+  implicit_aria_role : string option;
+}
+
+let make ~name ?(void = false) ?(categories = [])
+    ?(content_model = Content_model.Nothing) ?permitted_parents
+    ?(prohibited_ancestors = []) ?(tag_omission = false) ?(attrs = [])
+    ?implicit_aria_role () =
+  {
+    name;
+    void;
+    categories;
+    content_model;
+    permitted_parents;
+    prohibited_ancestors;
+    tag_omission;
+    attrs;
+    implicit_aria_role;
+  }
+
+let is_void t = t.void
+
+let has_category t category = List.mem category t.categories
+
+let pp fmt t =
+  Format.fprintf fmt "@[<v 2>{ name = %S;@ void = %b;@ " t.name t.void;
+  Format.fprintf fmt "categories = [%a];@ "
+    (Format.pp_print_list
+       ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+       Content_category.pp)
+    t.categories;
+  Format.fprintf fmt "content_model = %a;@ " Content_model.pp t.content_model;
+  (match t.permitted_parents with
+  | None -> Format.fprintf fmt "permitted_parents = None;@ "
+  | Some parents ->
+      Format.fprintf fmt "permitted_parents = Some [%a];@ "
+        (Format.pp_print_list
+           ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+           (fun fmt s -> Format.fprintf fmt "%S" s))
+        parents);
+  Format.fprintf fmt "prohibited_ancestors = [%a];@ "
+    (Format.pp_print_list
+       ~pp_sep:(fun fmt () -> Format.fprintf fmt "; ")
+       (fun fmt s -> Format.fprintf fmt "%S" s))
+    t.prohibited_ancestors;
+  Format.fprintf fmt "tag_omission = %b;@ " t.tag_omission;
+  Format.fprintf fmt "attrs = [%a];@ "
+    (Format.pp_print_list
+       ~pp_sep:(fun fmt () -> Format.fprintf fmt ";@ ")
+       Attr_spec.pp)
+    t.attrs;
+  (match t.implicit_aria_role with
+  | None -> Format.fprintf fmt "implicit_aria_role = None }@]"
+  | Some role -> Format.fprintf fmt "implicit_aria_role = Some %S }@]" role)

lib/html5_checker/content_model/element_spec.mli

···
+(** HTML5 element specifications.
+
+    Defines the complete specification for an HTML5 element including content
+    model, categories, and attributes. *)
+
+type t = {
+  name : string;
+  void : bool;  (** Is void element? *)
+  categories : Content_category.t list;  (** What categories it belongs to *)
+  content_model : Content_model.t;  (** What children are allowed *)
+  permitted_parents : string list option;  (** Explicit parent restrictions *)
+  prohibited_ancestors : string list;  (** Cannot appear inside these *)
+  tag_omission : bool;  (** Can end tag be omitted? *)
+  attrs : Attr_spec.t list;  (** Element-specific attributes *)
+  implicit_aria_role : string option;  (** Default ARIA role *)
+}
+
+val make :
+  name:string ->
+  ?void:bool ->
+  ?categories:Content_category.t list ->
+  ?content_model:Content_model.t ->
+  ?permitted_parents:string list ->
+  ?prohibited_ancestors:string list ->
+  ?tag_omission:bool ->
+  ?attrs:Attr_spec.t list ->
+  ?implicit_aria_role:string ->
+  unit ->
+  t
+
+val is_void : t -> bool
+
+val has_category : t -> Content_category.t -> bool
+
+val pp : Format.formatter -> t -> unit

lib/html5_checker/content_model/elements_document.ml

···
+(** Document structure elements *)
+
+let html =
+  Element_spec.make ~name:"html"
+    ~content_model:
+      (Content_model.Sequence
+         [
+           Content_model.Optional (Content_model.Elements [ "head" ]);
+           Content_model.Optional (Content_model.Elements [ "body" ]);
+         ])
+    ~implicit_aria_role:"document" ()
+
+let head =
+  Element_spec.make ~name:"head" ~categories:[]
+    ~content_model:
+      (Content_model.Zero_or_more (Content_model.Categories [ Metadata ]))
+    ()
+
+let body =
+  Element_spec.make ~name:"body" ~categories:[ Sectioning ]
+    ~content_model:(Content_model.Categories [ Flow ]) ()
+
+let title =
+  Element_spec.make ~name:"title" ~categories:[ Metadata ]
+    ~content_model:Content_model.Text ()
+
+let base =
+  Element_spec.make ~name:"base" ~void:true ~categories:[ Metadata ]
+    ~content_model:Content_model.Nothing ()
+
+let link =
+  Element_spec.make ~name:"link" ~void:true ~categories:[ Metadata ]
+    ~content_model:Content_model.Nothing ()
+
+let meta =
+  Element_spec.make ~name:"meta" ~void:true ~categories:[ Metadata ]
+    ~content_model:Content_model.Nothing ()
+
+let style =
+  Element_spec.make ~name:"style" ~categories:[ Metadata ]
+    ~content_model:Content_model.Text ()
+
+(** Sectioning elements *)
+
+let article =
+  Element_spec.make ~name:"article" ~categories:[ Flow; Sectioning; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ]) ()
+
+let section =
+  Element_spec.make ~name:"section" ~categories:[ Flow; Sectioning; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ]) ()
+
+let nav =
+  Element_spec.make ~name:"nav" ~categories:[ Flow; Sectioning; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ])
+    ~implicit_aria_role:"navigation" ()
+
+let aside =
+  Element_spec.make ~name:"aside" ~categories:[ Flow; Sectioning; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ])
+    ~implicit_aria_role:"complementary" ()
+
+let h1 =
+  Element_spec.make ~name:"h1" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ])
+    ~implicit_aria_role:"heading" ()
+
+let h2 =
+  Element_spec.make ~name:"h2" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ])
+    ~implicit_aria_role:"heading" ()
+
+let h3 =
+  Element_spec.make ~name:"h3" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ])
+    ~implicit_aria_role:"heading" ()
+
+let h4 =
+  Element_spec.make ~name:"h4" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ])
+    ~implicit_aria_role:"heading" ()
+
+let h5 =
+  Element_spec.make ~name:"h5" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ])
+    ~implicit_aria_role:"heading" ()
+
+let h6 =
+  Element_spec.make ~name:"h6" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ])
+    ~implicit_aria_role:"heading" ()
+
+let hgroup =
+  Element_spec.make ~name:"hgroup" ~categories:[ Flow; Heading; Palpable ]
+    ~content_model:
+      (Content_model.Sequence
+         [
+           Content_model.Zero_or_more
+             (Content_model.Choice
+                [
+                  Content_model.Elements [ "p" ];
+                  Content_model.Categories [ Heading ];
+                ]);
+         ])
+    ~implicit_aria_role:"group" ()
+
+let header =
+  Element_spec.make ~name:"header" ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Content_model.Except
+         ( Content_model.Categories [ Flow ],
+           [] (* no header/footer descendants *) ))
+    ~prohibited_ancestors:[ "header"; "footer" ] ~implicit_aria_role:"banner" ()
+
+let footer =
+  Element_spec.make ~name:"footer" ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Content_model.Except
+         ( Content_model.Categories [ Flow ],
+           [] (* no header/footer descendants *) ))
+    ~prohibited_ancestors:[ "header"; "footer" ]
+    ~implicit_aria_role:"contentinfo" ()
+
+let address =
+  Element_spec.make ~name:"address" ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Content_model.Except
+         ( Content_model.Categories [ Flow ],
+           [ Heading; Sectioning ] (* no heading/sectioning content *) ))
+    ~prohibited_ancestors:[ "address" ] ()
+
+let main =
+  Element_spec.make ~name:"main" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ])
+    ~implicit_aria_role:"main" ()
+
+(** Grouping elements *)
+
+let p =
+  Element_spec.make ~name:"p" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ]) ()
+
+let hr =
+  Element_spec.make ~name:"hr" ~void:true ~categories:[ Flow ]
+    ~content_model:Content_model.Nothing ~implicit_aria_role:"separator" ()
+
+let pre =
+  Element_spec.make ~name:"pre" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Categories [ Phrasing ]) ()
+
+let blockquote =
+  Element_spec.make ~name:"blockquote" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ]) ()
+
+let ol =
+  Element_spec.make ~name:"ol" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Zero_or_more (Content_model.Elements [ "li" ]))
+    ~implicit_aria_role:"list" ()
+
+let ul =
+  Element_spec.make ~name:"ul" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Zero_or_more (Content_model.Elements [ "li" ]))
+    ~implicit_aria_role:"list" ()
+
+let menu =
+  Element_spec.make ~name:"menu" ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Content_model.Zero_or_more
+         (Content_model.Choice
+            [
+              Content_model.Elements [ "li" ];
+              Content_model.Elements [ "script" ];
+              Content_model.Elements [ "template" ];
+            ]))
+    ~implicit_aria_role:"list" ()
+
+let li =
+  Element_spec.make ~name:"li" ~categories:[]
+    ~content_model:(Content_model.Categories [ Flow ])
+    ~permitted_parents:[ "ol"; "ul"; "menu" ] ~implicit_aria_role:"listitem" ()
+
+let dl =
+  Element_spec.make ~name:"dl" ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Content_model.Choice
+         [
+           Content_model.Zero_or_more
+             (Content_model.Sequence
+                [
+                  Content_model.One_or_more (Content_model.Elements [ "dt" ]);
+                  Content_model.One_or_more (Content_model.Elements [ "dd" ]);
+                ]);
+           Content_model.Zero_or_more
+             (Content_model.Choice
+                [
+                  Content_model.Elements [ "div" ];
+                  Content_model.Elements [ "script" ];
+                  Content_model.Elements [ "template" ];
+                ]);
+         ])
+    ()
+
+let dt =
+  Element_spec.make ~name:"dt" ~categories:[]
+    ~content_model:
+      (Content_model.Except
+         ( Content_model.Categories [ Flow ],
+           [ Heading; Sectioning ] (* no heading/sectioning *) ))
+    ~permitted_parents:[ "dl"; "div" ] ()
+
+let dd =
+  Element_spec.make ~name:"dd" ~categories:[]
+    ~content_model:(Content_model.Categories [ Flow ])
+    ~permitted_parents:[ "dl"; "div" ] ()
+
+let figure =
+  Element_spec.make ~name:"figure" ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Content_model.Choice
+         [
+           Content_model.Sequence
+             [
+               Content_model.Optional
+                 (Content_model.Elements [ "figcaption" ]);
+               Content_model.Categories [ Flow ];
+             ];
+           Content_model.Sequence
+             [
+               Content_model.Categories [ Flow ];
+               Content_model.Optional
+                 (Content_model.Elements [ "figcaption" ]);
+             ];
+         ])
+    ~implicit_aria_role:"figure" ()
+
+let figcaption =
+  Element_spec.make ~name:"figcaption" ~categories:[]
+    ~content_model:(Content_model.Categories [ Flow ])
+    ~permitted_parents:[ "figure" ] ()
+
+let div =
+  Element_spec.make ~name:"div" ~categories:[ Flow; Palpable ]
+    ~content_model:(Content_model.Categories [ Flow ]) ()
+
+(** Element registry *)
+
+let all =
+  [
+    (* Document structure *)
+    html;
+    head;
+    body;
+    title;
+    base;
+    link;
+    meta;
+    style;
+    (* Sectioning *)
+    article;
+    section;
+    nav;
+    aside;
+    h1;
+    h2;
+    h3;
+    h4;
+    h5;
+    h6;
+    hgroup;
+    header;
+    footer;
+    address;
+    main;
+    (* Grouping *)
+    p;
+    hr;
+    pre;
+    blockquote;
+    ol;
+    ul;
+    menu;
+    li;
+    dl;
+    dt;
+    dd;
+    figure;
+    figcaption;
+    div;
+  ]

lib/html5_checker/content_model/elements_document.mli

···
+(** HTML5 structural and document element specifications.
+
+    This module defines element specifications for HTML5 document structure,
+    sectioning, and grouping elements according to the WHATWG HTML specification.
+
+    @see <https://html.spec.whatwg.org/multipage/> WHATWG HTML Specification *)
+
+(** {1 Document structure elements} *)
+
+val html : Element_spec.t
+(** The [html] element represents the root of an HTML document. *)
+
+val head : Element_spec.t
+(** The [head] element represents a collection of metadata for the document. *)
+
+val body : Element_spec.t
+(** The [body] element represents the contents of the document. *)
+
+val title : Element_spec.t
+(** The [title] element represents the document's title or name. *)
+
+val base : Element_spec.t
+(** The [base] element specifies the document base URL and/or default browsing
+    context for navigation. *)
+
+val link : Element_spec.t
+(** The [link] element specifies relationships between the current document and
+    external resources. *)
+
+val meta : Element_spec.t
+(** The [meta] element represents various kinds of metadata that cannot be
+    expressed using other metadata elements. *)
+
+val style : Element_spec.t
+(** The [style] element allows authors to embed CSS style sheets in their documents. *)
+
+(** {1 Sectioning elements} *)
+
+val article : Element_spec.t
+(** The [article] element represents a complete, or self-contained, composition
+    in a document, page, application, or site. *)
+
+val section : Element_spec.t
+(** The [section] element represents a generic section of a document or application. *)
+
+val nav : Element_spec.t
+(** The [nav] element represents a section of a page that links to other pages
+    or to parts within the page. *)
+
+val aside : Element_spec.t
+(** The [aside] element represents a section of a page that consists of content
+    that is tangentially related to the content around it. *)
+
+val h1 : Element_spec.t
+(** The [h1] element represents a heading at level 1. *)
+
+val h2 : Element_spec.t
+(** The [h2] element represents a heading at level 2. *)
+
+val h3 : Element_spec.t
+(** The [h3] element represents a heading at level 3. *)
+
+val h4 : Element_spec.t
+(** The [h4] element represents a heading at level 4. *)
+
+val h5 : Element_spec.t
+(** The [h5] element represents a heading at level 5. *)
+
+val h6 : Element_spec.t
+(** The [h6] element represents a heading at level 6. *)
+
+val hgroup : Element_spec.t
+(** The [hgroup] element represents a heading and related content, such as
+    subheadings, an alternative title, or a tagline. *)
+
+val header : Element_spec.t
+(** The [header] element represents introductory content for its nearest ancestor
+    sectioning content or sectioning root element. *)
+
+val footer : Element_spec.t
+(** The [footer] element represents a footer for its nearest ancestor sectioning
+    content or sectioning root element. *)
+
+val address : Element_spec.t
+(** The [address] element represents contact information for its nearest [article]
+    or [body] element ancestor. *)
+
+val main : Element_spec.t
+(** The [main] element represents the dominant contents of the document. *)
+
+(** {1 Grouping elements} *)
+
+val p : Element_spec.t
+(** The [p] element represents a paragraph. *)
+
+val hr : Element_spec.t
+(** The [hr] element represents a thematic break between paragraph-level elements. *)
+
+val pre : Element_spec.t
+(** The [pre] element represents a block of preformatted text. *)
+
+val blockquote : Element_spec.t
+(** The [blockquote] element represents a section that is quoted from another source. *)
+
+val ol : Element_spec.t
+(** The [ol] element represents a list of items, where the items have been
+    intentionally ordered. *)
+
+val ul : Element_spec.t
+(** The [ul] element represents a list of items, where the order of the items
+    is not important. *)
+
+val menu : Element_spec.t
+(** The [menu] element represents a toolbar consisting of its contents, in the
+    form of an unordered list of items. *)
+
+val li : Element_spec.t
+(** The [li] element represents a list item. *)
+
+val dl : Element_spec.t
+(** The [dl] element represents an association list consisting of zero or more
+    name-value groups (a description list). *)
+
+val dt : Element_spec.t
+(** The [dt] element represents the term, or name, part of a term-description
+    group in a description list. *)
+
+val dd : Element_spec.t
+(** The [dd] element represents the description, definition, or value, part of
+    a term-description group in a description list. *)
+
+val figure : Element_spec.t
+(** The [figure] element represents some flow content, optionally with a caption,
+    that is self-contained and is typically referenced as a single unit from
+    the main flow of the document. *)
+
+val figcaption : Element_spec.t
+(** The [figcaption] element represents a caption or legend for the rest of the
+    contents of the parent [figure] element. *)
+
+val div : Element_spec.t
+(** The [div] element has no special meaning at all. It represents its children. *)
+
+(** {1 Element registry} *)
+
+val all : Element_spec.t list
+(** [all] contains all element specifications defined in this module. *)

lib/html5_checker/content_model/elements_embedded.ml

···
+open Content_category
+open Content_model
+open Attr_spec
+
+let picture =
+  Element_spec.make ~name:"picture"
+    ~categories:[ Flow; Phrasing; Embedded; Palpable ]
+    ~content_model:
+      (Sequence
+         [
+           Zero_or_more (Elements [ "source" ]);
+           Elements [ "img" ];
+           Zero_or_more (Elements [ "script"; "template" ]);
+         ])
+    ~attrs:[] ()
+
+let source =
+  Element_spec.make ~name:"source" ~void:true
+    ~categories:[]
+    ~content_model:Nothing
+    ~attrs:
+      [
+        make "type" ~datatype:"mime" ();
+        make "media" ~datatype:"media_query" ();
+        make "src" ~datatype:"url" ();
+        make "srcset" ~datatype:"srcset" ();
+        make "sizes" ();
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+      ]
+    ()
+
+let img =
+  Element_spec.make ~name:"img" ~void:true
+    ~categories:[ Flow; Phrasing; Embedded; Palpable; Interactive ]
+    ~content_model:Nothing
+    ~attrs:
+      [
+        make "src" ~required:true ~datatype:"url" ();
+        make "alt" ();
+        make "srcset" ~datatype:"srcset" ();
+        make "sizes" ();
+        make "crossorigin" ~datatype:"crossorigin" ();
+        make "usemap" ~datatype:"hash" ();
+        make "ismap" ~datatype:"boolean" ();
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+        make "referrerpolicy" ~datatype:"referrer" ();
+        make "decoding" ~datatype:"decoding" ();
+        make "loading" ~datatype:"loading" ();
+        make "fetchpriority" ~datatype:"fetchpriority" ();
+      ]
+    ~implicit_aria_role:"img" ()
+
+let iframe =
+  Element_spec.make ~name:"iframe"
+    ~categories:[ Flow; Phrasing; Embedded; Interactive; Palpable ]
+    ~content_model:Nothing
+    ~attrs:
+      [
+        make "src" ~datatype:"url" ();
+        make "srcdoc" ();
+        make "name" ~datatype:"target" ();
+        make "sandbox" ~datatype:"sandbox" ();
+        make "allow" ();
+        make "allowfullscreen" ~datatype:"boolean" ();
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+        make "referrerpolicy" ~datatype:"referrer" ();
+        make "loading" ~datatype:"loading" ();
+      ]
+    ()
+
+let embed =
+  Element_spec.make ~name:"embed" ~void:true
+    ~categories:[ Flow; Phrasing; Embedded; Interactive; Palpable ]
+    ~content_model:Nothing
+    ~attrs:
+      [
+        make "src" ~required:true ~datatype:"url" ();
+        make "type" ~datatype:"mime" ();
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+      ]
+    ()
+
+let object_ =
+  Element_spec.make ~name:"object"
+    ~categories:[ Flow; Phrasing; Embedded; Palpable; Interactive ]
+    ~content_model:(Mixed [ Flow ])
+    ~attrs:
+      [
+        make "data" ~datatype:"url" ();
+        make "type" ~datatype:"mime" ();
+        make "name" ~datatype:"target" ();
+        make "form" ~datatype:"id" ();
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+      ]
+    ()
+
+let param =
+  Element_spec.make ~name:"param" ~void:true
+    ~categories:[]
+    ~content_model:Nothing
+    ~attrs:[ make "name" ~required:true (); make "value" ~required:true () ]
+    ()
+
+let video =
+  Element_spec.make ~name:"video"
+    ~categories:[ Flow; Phrasing; Embedded; Palpable; Interactive ]
+    ~content_model:
+      (Choice
+         [
+           Sequence
+             [
+               Zero_or_more (Elements [ "source" ]);
+               Zero_or_more (Elements [ "track" ]);
+               Zero_or_more Transparent;
+             ];
+           Sequence [ Zero_or_more Transparent; Zero_or_more (Elements [ "track" ]) ];
+         ])
+    ~prohibited_ancestors:[ "audio"; "video" ]
+    ~attrs:
+      [
+        make "src" ~datatype:"url" ();
+        make "crossorigin" ~datatype:"crossorigin" ();
+        make "poster" ~datatype:"url" ();
+        make "preload" ~datatype:"preload" ();
+        make "autoplay" ~datatype:"boolean" ();
+        make "playsinline" ~datatype:"boolean" ();
+        make "loop" ~datatype:"boolean" ();
+        make "muted" ~datatype:"boolean" ();
+        make "controls" ~datatype:"boolean" ();
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+      ]
+    ()
+
+let audio =
+  Element_spec.make ~name:"audio"
+    ~categories:[ Flow; Phrasing; Embedded; Palpable; Interactive ]
+    ~content_model:
+      (Choice
+         [
+           Sequence
+             [
+               Zero_or_more (Elements [ "source" ]);
+               Zero_or_more (Elements [ "track" ]);
+               Zero_or_more Transparent;
+             ];
+           Sequence [ Zero_or_more Transparent; Zero_or_more (Elements [ "track" ]) ];
+         ])
+    ~prohibited_ancestors:[ "audio"; "video" ]
+    ~attrs:
+      [
+        make "src" ~datatype:"url" ();
+        make "crossorigin" ~datatype:"crossorigin" ();
+        make "preload" ~datatype:"preload" ();
+        make "autoplay" ~datatype:"boolean" ();
+        make "loop" ~datatype:"boolean" ();
+        make "muted" ~datatype:"boolean" ();
+        make "controls" ~datatype:"boolean" ();
+      ]
+    ()
+
+let track =
+  Element_spec.make ~name:"track" ~void:true
+    ~categories:[]
+    ~content_model:Nothing
+    ~permitted_parents:[ "audio"; "video" ]
+    ~attrs:
+      [
+        make "kind" ~datatype:"kind" ();
+        make "src" ~required:true ~datatype:"url" ();
+        make "srclang" ~datatype:"language" ();
+        make "label" ();
+        make "default" ~datatype:"boolean" ();
+      ]
+    ()
+
+let map =
+  Element_spec.make ~name:"map"
+    ~categories:[ Flow; Phrasing; Palpable ]
+    ~content_model:Transparent
+    ~attrs:[ make "name" ~required:true () ] ()
+
+let area =
+  Element_spec.make ~name:"area" ~void:true
+    ~categories:[ Flow; Phrasing ]
+    ~content_model:Nothing
+    ~attrs:
+      [
+        make "alt" ();
+        make "coords" ~datatype:"coords" ();
+        make "shape" ~datatype:"shape" ();
+        make "href" ~datatype:"url" ();
+        make "target" ~datatype:"target" ();
+        make "download" ();
+        make "ping" ();
+        make "rel" ~datatype:"link_type" ();
+        make "referrerpolicy" ~datatype:"referrer" ();
+      ]
+    ~implicit_aria_role:"link" ()
+
+let all =
+  [
+    picture;
+    source;
+    img;
+    iframe;
+    embed;
+    object_;
+    param;
+    video;
+    audio;
+    track;
+    map;
+    area;
+  ]

lib/html5_checker/content_model/elements_embedded.mli

···
+(** HTML5 embedded content element specifications.
+
+    Embedded content elements import resources into the document.
+    See https://html.spec.whatwg.org/multipage/embedded-content.html *)
+
+val picture : Element_spec.t
+(** The picture element contains zero or more source elements followed by
+    one img element to offer alternative versions of an image for different
+    display scenarios. *)
+
+val source : Element_spec.t
+(** The source element specifies multiple media resources for picture, audio,
+    and video elements. It is a void element. *)
+
+val img : Element_spec.t
+(** The img element represents an image. It is a void element. *)
+
+val iframe : Element_spec.t
+(** The iframe element represents a nested browsing context. *)
+
+val embed : Element_spec.t
+(** The embed element provides an integration point for an external application
+    or interactive content. It is a void element. *)
+
+val object_ : Element_spec.t
+(** The object element can represent an external resource, which is treated as
+    an image, a nested browsing context, or a plugin. *)
+
+val param : Element_spec.t
+(** The param element defines parameters for plugins invoked by object elements.
+    Deprecated in favor of using data attributes. It is a void element. *)
+
+val video : Element_spec.t
+(** The video element is used for playing videos or movies, and audio files
+    with captions. *)
+
+val audio : Element_spec.t
+(** The audio element represents a sound or audio stream. *)
+
+val track : Element_spec.t
+(** The track element allows authors to specify explicit external timed text
+    tracks for media elements. It is a void element. *)
+
+val map : Element_spec.t
+(** The map element, in conjunction with img and area elements, defines an
+    image map. *)
+
+val area : Element_spec.t
+(** The area element represents either a hyperlink with some text and a
+    corresponding area on an image map, or a dead area on an image map.
+    It is a void element. *)
+
+val all : Element_spec.t list
+(** List of all embedded content element specifications. *)

lib/html5_checker/content_model/elements_form.ml

···
+open Content_category
+open Content_model
+
+let form =
+  Element_spec.make ~name:"form"
+    ~categories:[Flow; Palpable]
+    ~content_model:(Except (Categories [Flow], []))
+    ~attrs:[
+      Attr_spec.make "accept-charset" ~datatype:"string" ();
+      Attr_spec.make "action" ~datatype:"url" ();
+      Attr_spec.make "autocomplete" ~datatype:"autocomplete" ();
+      Attr_spec.make "enctype" ~datatype:"encoding" ();
+      Attr_spec.make "method" ~datatype:"method" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+      Attr_spec.make "novalidate" ~datatype:"boolean" ();
+      Attr_spec.make "target" ~datatype:"target" ();
+      Attr_spec.make "rel" ~datatype:"relationship" ();
+    ]
+    ~prohibited_ancestors:["form"]
+    ()
+
+let label =
+  Element_spec.make ~name:"label"
+    ~categories:[Flow; Phrasing; Interactive; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ~attrs:[
+      Attr_spec.make "for" ~datatype:"idref" ();
+    ]
+    ()
+
+let input =
+  Element_spec.make ~name:"input"
+    ~void:true
+    ~categories:[Flow; Phrasing; Interactive; Palpable]
+    ~content_model:Nothing
+    ~attrs:[
+      Attr_spec.make "accept" ~datatype:"string" ();
+      Attr_spec.make "alt" ~datatype:"string" ();
+      Attr_spec.make "autocomplete" ~datatype:"autocomplete" ();
+      Attr_spec.make "checked" ~datatype:"boolean" ();
+      Attr_spec.make "dirname" ~datatype:"directionality" ();
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "form" ~datatype:"idref" ();
+      Attr_spec.make "formaction" ~datatype:"url" ();
+      Attr_spec.make "formenctype" ~datatype:"encoding" ();
+      Attr_spec.make "formmethod" ~datatype:"method" ();
+      Attr_spec.make "formnovalidate" ~datatype:"boolean" ();
+      Attr_spec.make "formtarget" ~datatype:"target" ();
+      Attr_spec.make "height" ~datatype:"integer" ();
+      Attr_spec.make "list" ~datatype:"idref" ();
+      Attr_spec.make "max" ~datatype:"string" ();
+      Attr_spec.make "maxlength" ~datatype:"integer" ();
+      Attr_spec.make "min" ~datatype:"string" ();
+      Attr_spec.make "minlength" ~datatype:"integer" ();
+      Attr_spec.make "multiple" ~datatype:"boolean" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+      Attr_spec.make "pattern" ~datatype:"string" ();
+      Attr_spec.make "placeholder" ~datatype:"string" ();
+      Attr_spec.make "popovertarget" ~datatype:"string" ();
+      Attr_spec.make "popovertargetaction" ~datatype:"popovertargetaction" ();
+      Attr_spec.make "readonly" ~datatype:"boolean" ();
+      Attr_spec.make "required" ~datatype:"boolean" ();
+      Attr_spec.make "size" ~datatype:"integer" ();
+      Attr_spec.make "src" ~datatype:"url" ();
+      Attr_spec.make "step" ~datatype:"string" ();
+      Attr_spec.make "type" ~enum_values:[
+        "hidden"; "text"; "search"; "tel"; "url"; "email"; "password";
+        "date"; "month"; "week"; "time"; "datetime-local"; "number";
+        "range"; "color"; "checkbox"; "radio"; "file"; "submit"; "image";
+        "reset"; "button"
+      ] ();
+      Attr_spec.make "value" ~datatype:"string" ();
+      Attr_spec.make "width" ~datatype:"integer" ();
+    ]
+    ()
+
+let button =
+  Element_spec.make ~name:"button"
+    ~categories:[Flow; Phrasing; Interactive; Palpable]
+    ~content_model:(Except (Categories [Phrasing], [Interactive]))
+    ~attrs:[
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "form" ~datatype:"idref" ();
+      Attr_spec.make "formaction" ~datatype:"url" ();
+      Attr_spec.make "formenctype" ~datatype:"encoding" ();
+      Attr_spec.make "formmethod" ~datatype:"method" ();
+      Attr_spec.make "formnovalidate" ~datatype:"boolean" ();
+      Attr_spec.make "formtarget" ~datatype:"target" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+      Attr_spec.make "popovertarget" ~datatype:"string" ();
+      Attr_spec.make "popovertargetaction" ~datatype:"popovertargetaction" ();
+      Attr_spec.make "type" ~enum_values:["submit"; "reset"; "button"] ();
+      Attr_spec.make "value" ~datatype:"string" ();
+    ]
+    ()
+
+let select =
+  Element_spec.make ~name:"select"
+    ~categories:[Flow; Phrasing; Interactive; Palpable]
+    ~content_model:(Elements ["option"; "optgroup"; "script"; "template"])
+    ~attrs:[
+      Attr_spec.make "autocomplete" ~datatype:"autocomplete" ();
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "form" ~datatype:"idref" ();
+      Attr_spec.make "multiple" ~datatype:"boolean" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+      Attr_spec.make "required" ~datatype:"boolean" ();
+      Attr_spec.make "size" ~datatype:"integer" ();
+    ]
+    ~implicit_aria_role:"combobox"
+    ()
+
+let datalist =
+  Element_spec.make ~name:"datalist"
+    ~categories:[Flow; Phrasing]
+    ~content_model:(Choice [
+      Categories [Phrasing];
+      Elements ["option"; "script"; "template"]
+    ])
+    ~implicit_aria_role:"listbox"
+    ()
+
+let optgroup =
+  Element_spec.make ~name:"optgroup"
+    ~categories:[]
+    ~content_model:(Elements ["option"; "script"; "template"])
+    ~attrs:[
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "label" ~required:true ~datatype:"string" ();
+    ]
+    ~permitted_parents:["select"]
+    ~implicit_aria_role:"group"
+    ()
+
+let option =
+  Element_spec.make ~name:"option"
+    ~categories:[]
+    ~content_model:Text
+    ~attrs:[
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "label" ~datatype:"string" ();
+      Attr_spec.make "selected" ~datatype:"boolean" ();
+      Attr_spec.make "value" ~datatype:"string" ();
+    ]
+    ~permitted_parents:["select"; "datalist"; "optgroup"]
+    ~implicit_aria_role:"option"
+    ()
+
+let textarea =
+  Element_spec.make ~name:"textarea"
+    ~categories:[Flow; Phrasing; Interactive; Palpable]
+    ~content_model:Text
+    ~attrs:[
+      Attr_spec.make "autocomplete" ~datatype:"autocomplete" ();
+      Attr_spec.make "cols" ~datatype:"integer" ();
+      Attr_spec.make "dirname" ~datatype:"directionality" ();
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "form" ~datatype:"idref" ();
+      Attr_spec.make "maxlength" ~datatype:"integer" ();
+      Attr_spec.make "minlength" ~datatype:"integer" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+      Attr_spec.make "placeholder" ~datatype:"string" ();
+      Attr_spec.make "readonly" ~datatype:"boolean" ();
+      Attr_spec.make "required" ~datatype:"boolean" ();
+      Attr_spec.make "rows" ~datatype:"integer" ();
+      Attr_spec.make "wrap" ~enum_values:["soft"; "hard"] ();
+    ]
+    ~implicit_aria_role:"textbox"
+    ()
+
+let output =
+  Element_spec.make ~name:"output"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ~attrs:[
+      Attr_spec.make "for" ~datatype:"idrefs" ();
+      Attr_spec.make "form" ~datatype:"idref" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+    ]
+    ~implicit_aria_role:"status"
+    ()
+
+let progress =
+  Element_spec.make ~name:"progress"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Except (Categories [Phrasing], []))
+    ~attrs:[
+      Attr_spec.make "value" ~datatype:"float" ();
+      Attr_spec.make "max" ~datatype:"float" ();
+    ]
+    ~prohibited_ancestors:["progress"]
+    ()
+
+let meter =
+  Element_spec.make ~name:"meter"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Except (Categories [Phrasing], []))
+    ~attrs:[
+      Attr_spec.make "value" ~required:true ~datatype:"float" ();
+      Attr_spec.make "min" ~datatype:"float" ();
+      Attr_spec.make "max" ~datatype:"float" ();
+      Attr_spec.make "low" ~datatype:"float" ();
+      Attr_spec.make "high" ~datatype:"float" ();
+      Attr_spec.make "optimum" ~datatype:"float" ();
+    ]
+    ~prohibited_ancestors:["meter"]
+    ()
+
+let fieldset =
+  Element_spec.make ~name:"fieldset"
+    ~categories:[Flow; Palpable]
+    ~content_model:(Sequence [
+      Optional (Elements ["legend"]);
+      Categories [Flow]
+    ])
+    ~attrs:[
+      Attr_spec.make "disabled" ~datatype:"boolean" ();
+      Attr_spec.make "form" ~datatype:"idref" ();
+      Attr_spec.make "name" ~datatype:"string" ();
+    ]
+    ~implicit_aria_role:"group"
+    ()
+
+let legend =
+  Element_spec.make ~name:"legend"
+    ~categories:[]
+    ~content_model:(Choice [
+      Categories [Phrasing];
+      Categories [Phrasing; Heading]
+    ])
+    ~permitted_parents:["fieldset"]
+    ()
+
+let all = [
+  form; label; input; button; select; datalist; optgroup; option;
+  textarea; output; progress; meter; fieldset; legend
+]

lib/html5_checker/content_model/elements_form.mli

···
+(** HTML5 form element specifications.
+
+    Form-associated elements for user input and form submission.
+    See https://html.spec.whatwg.org/multipage/forms.html *)
+
+(** {1 Form Container} *)
+
+val form : Element_spec.t
+(** The form element represents a hyperlink that can be manipulated through a
+    collection of form-associated elements, some of which can represent editable
+    values that can be submitted to a server for processing.
+
+    Content model: Flow content, but must not contain form element descendants. *)
+
+(** {1 Form Controls} *)
+
+val label : Element_spec.t
+(** The label element represents a caption in a user interface. The caption can
+    be associated with a specific form control, known as the label element's
+    labeled control.
+
+    Content model: Phrasing content, but must not contain descendant label
+    elements, and must not contain form control descendants other than the
+    labeled control. *)
+
+val input : Element_spec.t
+(** The input element represents a typed data field, usually with a form control
+    to allow the user to edit the data. It is a void element.
+
+    Content model: Nothing (void element).
+
+    The type attribute controls the data type (and associated control) of the
+    element. *)
+
+val button : Element_spec.t
+(** The button element represents a button labeled by its contents.
+
+    Content model: Phrasing content, but must not contain interactive content
+    descendants. *)
+
+val select : Element_spec.t
+(** The select element represents a control for selecting amongst a set of
+    options.
+
+    Content model: Zero or more option, optgroup, and script-supporting elements. *)
+
+val datalist : Element_spec.t
+(** The datalist element represents a set of option elements that represent
+    predefined options for other controls. In the rendering, the datalist element
+    represents nothing and it, along with its children, should be hidden.
+
+    Content model: Either phrasing content or zero or more option and
+    script-supporting elements. *)
+
+val optgroup : Element_spec.t
+(** The optgroup element represents a group of option elements with a common
+    label.
+
+    Content model: Zero or more option and script-supporting elements. *)
+
+val option : Element_spec.t
+(** The option element represents an option in a select element or as part of a
+    list of suggestions in a datalist element.
+
+    Content model: Text, or empty if label attribute is present. *)
+
+val textarea : Element_spec.t
+(** The textarea element represents a multiline plain text edit control for the
+    element's raw value.
+
+    Content model: Text. *)
+
+val output : Element_spec.t
+(** The output element represents the result of a calculation performed by the
+    application, or the result of a user action.
+
+    Content model: Phrasing content. *)
+
+val progress : Element_spec.t
+(** The progress element represents the completion progress of a task.
+
+    Content model: Phrasing content, but must not contain progress element
+    descendants. *)
+
+val meter : Element_spec.t
+(** The meter element represents a scalar measurement within a known range, or a
+    fractional value; for example disk usage, the relevance of a query result, or
+    the fraction of a voting population to have selected a particular candidate.
+
+    Content model: Phrasing content, but must not contain meter element
+    descendants. *)
+
+val fieldset : Element_spec.t
+(** The fieldset element represents a set of form controls (or other content)
+    grouped together, optionally with a caption.
+
+    Content model: Optionally a legend element, followed by flow content. *)
+
+val legend : Element_spec.t
+(** The legend element represents a caption for the rest of the contents of the
+    legend element's parent fieldset element, if any.
+
+    Content model: Phrasing content, and optionally intermixed with heading
+    content. *)
+
+(** {1 Element List} *)
+
+val all : Element_spec.t list
+(** List of all form element specifications. *)

lib/html5_checker/content_model/elements_interactive.ml

···
+open Content_category
+open Content_model
+open Attr_spec
+
+let details =
+  Element_spec.make ~name:"details"
+    ~categories:[ Flow; Sectioning; Palpable; Interactive ]
+    ~content_model:
+      (Sequence [ Elements [ "summary" ]; Zero_or_more (Categories [ Flow ]) ])
+    ~attrs:[ make "open" ~datatype:"boolean" () ] ()
+
+let summary =
+  Element_spec.make ~name:"summary"
+    ~categories:[]
+    ~content_model:
+      (Choice [ Categories [ Phrasing ]; Categories [ Heading ] ])
+    ~permitted_parents:[ "details" ]
+    ~attrs:[] ()
+
+let dialog =
+  Element_spec.make ~name:"dialog"
+    ~categories:[ Flow; Sectioning ]
+    ~content_model:(Categories [ Flow ])
+    ~attrs:[ make "open" ~datatype:"boolean" () ] ~implicit_aria_role:"dialog" ()
+
+let script =
+  Element_spec.make ~name:"script"
+    ~categories:[ Metadata; Flow; Phrasing; Script_supporting ]
+    ~content_model:Text
+    ~attrs:
+      [
+        make "src" ~datatype:"url" ();
+        make "type" ();
+        make "nomodule" ~datatype:"boolean" ();
+        make "async" ~datatype:"boolean" ();
+        make "defer" ~datatype:"boolean" ();
+        make "crossorigin" ~datatype:"crossorigin" ();
+        make "integrity" ~datatype:"integrity" ();
+        make "referrerpolicy" ~datatype:"referrer" ();
+        make "blocking" ();
+        make "fetchpriority" ~datatype:"fetchpriority" ();
+      ]
+    ()
+
+let noscript =
+  Element_spec.make ~name:"noscript"
+    ~categories:[ Metadata; Flow; Phrasing ]
+    ~content_model:
+      (Choice
+         [
+           (* In head: link, style, meta *)
+           Categories [ Metadata ];
+           (* In body: transparent, but no noscript descendants *)
+           Transparent;
+         ])
+    ~prohibited_ancestors:[ "noscript" ]
+    ~attrs:[] ()
+
+let template =
+  Element_spec.make ~name:"template"
+    ~categories:[ Metadata; Flow; Phrasing; Script_supporting ]
+    ~content_model:Nothing
+    ~attrs:[] ()
+
+let slot =
+  Element_spec.make ~name:"slot"
+    ~categories:[ Flow; Phrasing ]
+    ~content_model:Transparent
+    ~attrs:[ make "name" () ] ()
+
+let canvas =
+  Element_spec.make ~name:"canvas"
+    ~categories:[ Flow; Phrasing; Embedded; Palpable ]
+    ~content_model:Transparent
+    ~attrs:
+      [
+        make "width" ~datatype:"integer" ();
+        make "height" ~datatype:"integer" ();
+      ]
+    ()
+
+let all = [ details; summary; dialog; script; noscript; template; slot; canvas ]

lib/html5_checker/content_model/elements_interactive.mli

···
+(** HTML5 interactive and scripting element specifications.
+
+    Interactive elements are specifically intended for user interaction,
+    and scripting elements support scripts in the document.
+    See https://html.spec.whatwg.org/multipage/interactive-elements.html
+    and https://html.spec.whatwg.org/multipage/scripting.html *)
+
+val details : Element_spec.t
+(** The details element represents a disclosure widget from which the user can
+    obtain additional information or controls. *)
+
+val summary : Element_spec.t
+(** The summary element represents a summary, caption, or legend for the rest
+    of the contents of the summary element's parent details element. *)
+
+val dialog : Element_spec.t
+(** The dialog element represents a part of an application that a user
+    interacts with to perform a task, such as a dialog box or modal. *)
+
+val script : Element_spec.t
+(** The script element allows authors to include dynamic script and data blocks
+    in their documents. *)
+
+val noscript : Element_spec.t
+(** The noscript element represents fallback content for when scripting is
+    disabled or not supported. *)
+
+val template : Element_spec.t
+(** The template element is used to declare fragments of HTML that can be cloned
+    and inserted in the document by script. *)
+
+val slot : Element_spec.t
+(** The slot element is used as a placeholder inside a web component that users
+    can fill with their own markup. *)
+
+val canvas : Element_spec.t
+(** The canvas element provides scripts with a resolution-dependent bitmap
+    canvas for rendering graphs, game graphics, art, or other visual images. *)
+
+val all : Element_spec.t list
+(** List of all interactive and scripting element specifications. *)

lib/html5_checker/content_model/elements_table.ml

···
+open Content_category
+open Content_model
+open Attr_spec
+
+let table =
+  Element_spec.make ~name:"table"
+    ~categories:[ Flow; Palpable ]
+    ~content_model:
+      (Sequence
+         [
+           Optional (Elements [ "caption" ]);
+           Zero_or_more (Elements [ "colgroup" ]);
+           Optional (Elements [ "thead" ]);
+           Choice
+             [
+               Sequence
+                 [
+                   Zero_or_more (Elements [ "tbody" ]);
+                   Optional (Elements [ "tfoot" ]);
+                 ];
+               Sequence
+                 [
+                   Optional (Elements [ "tfoot" ]);
+                   Zero_or_more (Elements [ "tbody" ]);
+                 ];
+               One_or_more (Elements [ "tr" ]);
+             ];
+           Zero_or_more (Elements [ "script"; "template" ]);
+         ])
+    ~attrs:[] ~implicit_aria_role:"table" ()
+
+let caption =
+  Element_spec.make ~name:"caption"
+    ~categories:[]
+    ~content_model:(Categories [ Flow ])
+    ~permitted_parents:[ "table" ]
+    ~prohibited_ancestors:[ "table" ]
+    ~attrs:[] ()
+
+let colgroup =
+  Element_spec.make ~name:"colgroup"
+    ~categories:[]
+    ~content_model:
+      (Choice
+         [
+           Zero_or_more (Elements [ "col" ]);
+           Zero_or_more (Elements [ "template" ]);
+         ])
+    ~permitted_parents:[ "table" ]
+    ~attrs:[ make "span" ~datatype:"integer" () ] ()
+
+let col =
+  Element_spec.make ~name:"col" ~void:true
+    ~categories:[]
+    ~content_model:Nothing
+    ~permitted_parents:[ "colgroup" ]
+    ~attrs:[ make "span" ~datatype:"integer" () ] ()
+
+let tbody =
+  Element_spec.make ~name:"tbody"
+    ~categories:[]
+    ~content_model:
+      (Choice
+         [
+           One_or_more (Elements [ "tr" ]); Zero_or_more (Elements [ "script"; "template" ]);
+         ])
+    ~permitted_parents:[ "table" ]
+    ~attrs:[] ~implicit_aria_role:"rowgroup" ()
+
+let thead =
+  Element_spec.make ~name:"thead"
+    ~categories:[]
+    ~content_model:
+      (Choice
+         [
+           One_or_more (Elements [ "tr" ]); Zero_or_more (Elements [ "script"; "template" ]);
+         ])
+    ~permitted_parents:[ "table" ]
+    ~attrs:[] ~implicit_aria_role:"rowgroup" ()
+
+let tfoot =
+  Element_spec.make ~name:"tfoot"
+    ~categories:[]
+    ~content_model:
+      (Choice
+         [
+           One_or_more (Elements [ "tr" ]); Zero_or_more (Elements [ "script"; "template" ]);
+         ])
+    ~permitted_parents:[ "table" ]
+    ~attrs:[] ~implicit_aria_role:"rowgroup" ()
+
+let tr =
+  Element_spec.make ~name:"tr"
+    ~categories:[]
+    ~content_model:
+      (Choice
+         [
+           One_or_more (Elements [ "td"; "th" ]);
+           Zero_or_more (Elements [ "script"; "template" ]);
+         ])
+    ~permitted_parents:[ "table"; "thead"; "tbody"; "tfoot" ]
+    ~attrs:[] ~implicit_aria_role:"row" ()
+
+let td =
+  Element_spec.make ~name:"td"
+    ~categories:[ Sectioning ]
+    ~content_model:(Categories [ Flow ])
+    ~permitted_parents:[ "tr" ]
+    ~attrs:
+      [
+        make "colspan" ~datatype:"integer" ();
+        make "rowspan" ~datatype:"integer" ();
+        make "headers" ();
+      ]
+    ~implicit_aria_role:"cell" ()
+
+let th =
+  Element_spec.make ~name:"th"
+    ~categories:[]
+    ~content_model:(Mixed [ Flow ])
+    ~prohibited_ancestors:[ "header"; "footer" ]
+    ~permitted_parents:[ "tr" ]
+    ~attrs:
+      [
+        make "colspan" ~datatype:"integer" ();
+        make "rowspan" ~datatype:"integer" ();
+        make "headers" ();
+        make "scope" ~datatype:"scope" ();
+        make "abbr" ();
+      ]
+    ~implicit_aria_role:"columnheader" ()
+
+let all = [ table; caption; colgroup; col; tbody; thead; tfoot; tr; td; th ]

lib/html5_checker/content_model/elements_table.mli

···
+(** HTML5 table element specifications.
+
+    Table elements represent data with more than one dimension.
+    See https://html.spec.whatwg.org/multipage/tables.html *)
+
+val table : Element_spec.t
+(** The table element represents data with more than one dimension in the form
+    of a table. *)
+
+val caption : Element_spec.t
+(** The caption element represents the title of the table. *)
+
+val colgroup : Element_spec.t
+(** The colgroup element represents a group of one or more columns in the table. *)
+
+val col : Element_spec.t
+(** The col element represents one or more columns in the table. It is a void
+    element. *)
+
+val tbody : Element_spec.t
+(** The tbody element represents a block of rows that consist of a body of data
+    for the table. *)
+
+val thead : Element_spec.t
+(** The thead element represents the block of rows that consist of the column
+    labels (headers) for the table. *)
+
+val tfoot : Element_spec.t
+(** The tfoot element represents the block of rows that consist of the column
+    summaries (footers) for the table. *)
+
+val tr : Element_spec.t
+(** The tr element represents a row of cells in a table. *)
+
+val td : Element_spec.t
+(** The td element represents a data cell in a table. *)
+
+val th : Element_spec.t
+(** The th element represents a header cell in a table. *)
+
+val all : Element_spec.t list
+(** List of all table element specifications. *)

lib/html5_checker/content_model/elements_text.ml

···
+open Content_category
+open Content_model
+
+let a =
+  Element_spec.make ~name:"a"
+    ~categories:[Flow; Phrasing; Interactive; Palpable]
+    ~content_model:(Except (Transparent, [Interactive]))
+    ~attrs:[
+      Attr_spec.make "href" ~datatype:"url" ();
+      Attr_spec.make "target" ~datatype:"target" ();
+      Attr_spec.make "download" ~datatype:"string" ();
+      Attr_spec.make "ping" ~datatype:"string" ();
+      Attr_spec.make "referrerpolicy" ~datatype:"referrerpolicy" ();
+      Attr_spec.make "rel" ~datatype:"relationship" ();
+      Attr_spec.make "hreflang" ~datatype:"string" ();
+      Attr_spec.make "type" ~datatype:"mimetype" ();
+    ]
+    ~implicit_aria_role:"link"
+    ()
+
+let em =
+  Element_spec.make ~name:"em"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let strong =
+  Element_spec.make ~name:"strong"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let small =
+  Element_spec.make ~name:"small"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let s =
+  Element_spec.make ~name:"s"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let cite =
+  Element_spec.make ~name:"cite"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let q =
+  Element_spec.make ~name:"q"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ~attrs:[
+      Attr_spec.make "cite" ~datatype:"url" ();
+    ]
+    ()
+
+let dfn =
+  Element_spec.make ~name:"dfn"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Except (Categories [Phrasing], []))
+    ~prohibited_ancestors:["dfn"]
+    ()
+
+let abbr =
+  Element_spec.make ~name:"abbr"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let ruby =
+  Element_spec.make ~name:"ruby"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let rt =
+  Element_spec.make ~name:"rt"
+    ~categories:[Phrasing]
+    ~content_model:(Categories [Phrasing])
+    ~permitted_parents:["ruby"; "rtc"]
+    ()
+
+let rp =
+  Element_spec.make ~name:"rp"
+    ~categories:[]
+    ~content_model:Text
+    ~permitted_parents:["ruby"; "rtc"]
+    ()
+
+let data =
+  Element_spec.make ~name:"data"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ~attrs:[
+      Attr_spec.make "value" ~required:true ~datatype:"string" ();
+    ]
+    ()
+
+let time =
+  Element_spec.make ~name:"time"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ~attrs:[
+      Attr_spec.make "datetime" ~datatype:"datetime" ();
+    ]
+    ~prohibited_ancestors:["time"]
+    ()
+
+let code =
+  Element_spec.make ~name:"code"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let var =
+  Element_spec.make ~name:"var"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let samp =
+  Element_spec.make ~name:"samp"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let kbd =
+  Element_spec.make ~name:"kbd"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let sub =
+  Element_spec.make ~name:"sub"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let sup =
+  Element_spec.make ~name:"sup"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let i =
+  Element_spec.make ~name:"i"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let b =
+  Element_spec.make ~name:"b"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let u =
+  Element_spec.make ~name:"u"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let mark =
+  Element_spec.make ~name:"mark"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let bdi =
+  Element_spec.make ~name:"bdi"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let bdo =
+  Element_spec.make ~name:"bdo"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ~attrs:[
+      Attr_spec.make "dir" ~required:true ~datatype:"dir" ();
+    ]
+    ()
+
+let span =
+  Element_spec.make ~name:"span"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:(Categories [Phrasing])
+    ()
+
+let br =
+  Element_spec.make ~name:"br"
+    ~void:true
+    ~categories:[Flow; Phrasing]
+    ~content_model:Nothing
+    ()
+
+let wbr =
+  Element_spec.make ~name:"wbr"
+    ~void:true
+    ~categories:[Flow; Phrasing]
+    ~content_model:Nothing
+    ()
+
+let ins =
+  Element_spec.make ~name:"ins"
+    ~categories:[Flow; Phrasing; Palpable]
+    ~content_model:Transparent
+    ~attrs:[
+      Attr_spec.make "cite" ~datatype:"url" ();
+      Attr_spec.make "datetime" ~datatype:"datetime" ();
+    ]
+    ()
+
+let del =
+  Element_spec.make ~name:"del"
+    ~categories:[Flow; Phrasing]
+    ~content_model:Transparent
+    ~attrs:[
+      Attr_spec.make "cite" ~datatype:"url" ();
+      Attr_spec.make "datetime" ~datatype:"datetime" ();
+    ]
+    ()
+
+let all = [
+  a; em; strong; small; s; cite; q; dfn; abbr; ruby; rt; rp;
+  data; time; code; var; samp; kbd; sub; sup; i; b; u; mark;
+  bdi; bdo; span; br; wbr; ins; del
+]

lib/html5_checker/content_model/elements_text.mli

···
+(** HTML5 text-level and edit element specifications.
+
+    Text-level semantic elements and edit tracking elements.
+    See https://html.spec.whatwg.org/multipage/text-level-semantics.html
+    and https://html.spec.whatwg.org/multipage/edits.html *)
+
+(** {1 Hyperlinks} *)
+
+val a : Element_spec.t
+(** The a element represents a hyperlink. When it has an href attribute, it
+    represents a hyperlink (a hypertext anchor) labeled by its contents.
+
+    Content model: Transparent, but must not contain interactive content
+    descendants. *)
+
+(** {1 Text-level Semantics} *)
+
+val em : Element_spec.t
+(** The em element represents stress emphasis of its contents. The level of
+    emphasis is given by its number of ancestor em elements.
+
+    Content model: Phrasing content. *)
+
+val strong : Element_spec.t
+(** The strong element represents strong importance, seriousness, or urgency
+    for its contents.
+
+    Content model: Phrasing content. *)
+
+val small : Element_spec.t
+(** The small element represents side comments such as small print. Small print
+    typically features disclaimers, caveats, legal restrictions, or copyrights.
+
+    Content model: Phrasing content. *)
+
+val s : Element_spec.t
+(** The s element represents contents that are no longer accurate or no longer
+    relevant.
+
+    Content model: Phrasing content. *)
+
+val cite : Element_spec.t
+(** The cite element represents the title of a work (e.g. a book, a paper,
+    an essay, a poem, a score, a song, a script, a film, a TV show, a game,
+    a sculpture, a painting, a theatre production, a play, an opera, a musical,
+    an exhibition, a legal case report, a computer program, etc).
+
+    Content model: Phrasing content. *)
+
+val q : Element_spec.t
+(** The q element represents some phrasing content quoted from another source.
+
+    Content model: Phrasing content. *)
+
+val dfn : Element_spec.t
+(** The dfn element represents the defining instance of a term.
+
+    Content model: Phrasing content, but must not contain dfn element descendants. *)
+
+val abbr : Element_spec.t
+(** The abbr element represents an abbreviation or acronym, optionally with its
+    expansion. The title attribute may be used to provide an expansion of the
+    abbreviation.
+
+    Content model: Phrasing content. *)
+
+val ruby : Element_spec.t
+(** The ruby element allows one or more spans of phrasing content to be marked
+    with ruby annotations. Ruby annotations are short runs of text presented
+    alongside base text, primarily used in East Asian typography.
+
+    Content model: Phrasing content, but must contain at least one rt or rp
+    element. *)
+
+val rt : Element_spec.t
+(** The rt element marks the ruby text component of a ruby annotation.
+
+    Content model: Phrasing content. *)
+
+val rp : Element_spec.t
+(** The rp element is used to provide fallback parentheses for browsers that
+    don't support ruby annotations.
+
+    Content model: Text, or phrasing content that represents what can be used
+    as fallback in annotations. *)
+
+val data : Element_spec.t
+(** The data element represents its contents, along with a machine-readable
+    form of those contents in the value attribute.
+
+    Content model: Phrasing content. *)
+
+val time : Element_spec.t
+(** The time element represents its contents, along with a machine-readable
+    form of those contents in the datetime attribute.
+
+    Content model: Phrasing content, but must not contain time element descendants. *)
+
+val code : Element_spec.t
+(** The code element represents a fragment of computer code.
+
+    Content model: Phrasing content. *)
+
+val var : Element_spec.t
+(** The var element represents a variable in a mathematical expression or a
+    programming context.
+
+    Content model: Phrasing content. *)
+
+val samp : Element_spec.t
+(** The samp element represents sample or quoted output from another program
+    or computing system.
+
+    Content model: Phrasing content. *)
+
+val kbd : Element_spec.t
+(** The kbd element represents user input (typically keyboard input, although
+    it may also be used to represent other input, such as voice commands).
+
+    Content model: Phrasing content. *)
+
+val sub : Element_spec.t
+(** The sub element represents a subscript.
+
+    Content model: Phrasing content. *)
+
+val sup : Element_spec.t
+(** The sup element represents a superscript.
+
+    Content model: Phrasing content. *)
+
+val i : Element_spec.t
+(** The i element represents a span of text in an alternate voice or mood, or
+    otherwise offset from the normal prose in a manner indicating a different
+    quality of text.
+
+    Content model: Phrasing content. *)
+
+val b : Element_spec.t
+(** The b element represents a span of text to which attention is being drawn
+    for utilitarian purposes without conveying any extra importance and with no
+    implication of an alternate voice or mood.
+
+    Content model: Phrasing content. *)
+
+val u : Element_spec.t
+(** The u element represents a span of text with an unarticulated, though
+    explicitly rendered, non-textual annotation, such as labeling the text as
+    being a proper name in Chinese text or labeling the text as being
+    misspelt.
+
+    Content model: Phrasing content. *)
+
+val mark : Element_spec.t
+(** The mark element represents a run of text in one document marked or
+    highlighted for reference purposes, due to its relevance in another context.
+
+    Content model: Phrasing content. *)
+
+val bdi : Element_spec.t
+(** The bdi element represents a span of text that is to be isolated from its
+    surroundings for the purposes of bidirectional text formatting.
+
+    Content model: Phrasing content. *)
+
+val bdo : Element_spec.t
+(** The bdo element represents explicit text directionality formatting control
+    for its children. It allows authors to override the Unicode bidirectional
+    algorithm.
+
+    Content model: Phrasing content. *)
+
+val span : Element_spec.t
+(** The span element doesn't mean anything on its own, but can be useful when
+    used together with the global attributes, e.g. class, lang, or dir.
+
+    Content model: Phrasing content. *)
+
+val br : Element_spec.t
+(** The br element represents a line break. It is a void element.
+
+    Content model: Nothing (void element). *)
+
+val wbr : Element_spec.t
+(** The wbr element represents a line break opportunity. It is a void element.
+
+    Content model: Nothing (void element). *)
+
+(** {1 Edits} *)
+
+val ins : Element_spec.t
+(** The ins element represents an addition to the document.
+
+    Content model: Transparent. *)
+
+val del : Element_spec.t
+(** The del element represents a removal from the document.
+
+    Content model: Transparent. *)
+
+(** {1 Element List} *)
+
+val all : Element_spec.t list
+(** List of all text-level and edit element specifications. *)

lib/html5_checker/datatype/datatype.ml

···
+module type S = sig
+  val name : string
+  val validate : string -> (unit, string) result
+  val is_valid : string -> bool
+end
+
+type t = (module S)
+
+let name (module D : S) = D.name
+let validate (module D : S) s = D.validate s
+let is_valid (module D : S) s = D.is_valid s
+
+(* Helper utilities *)
+
+let is_whitespace = function
+  | ' ' | '\t' | '\n' | '\r' | '\012' (* FF *) -> true
+  | _ -> false
+
+let is_ascii_digit = function '0' .. '9' -> true | _ -> false
+
+let to_ascii_lowercase c =
+  match c with 'A' .. 'Z' -> Char.chr (Char.code c + 32) | _ -> c
+
+let string_to_ascii_lowercase s =
+  String.map to_ascii_lowercase s
+
+let trim_html_spaces s =
+  let len = String.length s in
+  let rec find_start i =
+    if i >= len then len
+    else if is_whitespace s.[i] then find_start (i + 1)
+    else i
+  in
+  let rec find_end i =
+    if i < 0 then -1
+    else if is_whitespace s.[i] then find_end (i - 1)
+    else i
+  in
+  let start = find_start 0 in
+  let end_pos = find_end (len - 1) in
+  if start > end_pos then ""
+  else String.sub s start (end_pos - start + 1)

lib/html5_checker/datatype/datatype.mli

···
+(** HTML5 datatype validation.
+
+    This module provides the base interface for HTML5 attribute datatype
+    validators. Each datatype validates string values according to HTML5 spec. *)
+
+(** A datatype validator *)
+module type S = sig
+  (** Name of this datatype (e.g., "integer", "url") *)
+  val name : string
+
+  (** Validate a string value. Returns Ok () if valid, Error message otherwise *)
+  val validate : string -> (unit, string) result
+
+  (** Check if value is valid (convenience function) *)
+  val is_valid : string -> bool
+end
+
+(** A datatype packed as a first-class module *)
+type t = (module S)
+
+(** Get the name of a datatype *)
+val name : t -> string
+
+(** Validate a value with a datatype *)
+val validate : t -> string -> (unit, string) result
+
+(** Check if a value is valid *)
+val is_valid : t -> string -> bool
+
+(** Helper utilities for implementing datatype validators. *)
+
+(** Check if a character is HTML5 whitespace (space, tab, LF, FF, or CR). *)
+val is_whitespace : char -> bool
+
+(** Check if a character is an ASCII digit (0-9). *)
+val is_ascii_digit : char -> bool
+
+(** Convert an ASCII character to lowercase. *)
+val to_ascii_lowercase : char -> char
+
+(** Convert an ASCII string to lowercase. *)
+val string_to_ascii_lowercase : string -> string
+
+(** Trim HTML5 whitespace from both ends of a string. *)
+val trim_html_spaces : string -> string

lib/html5_checker/datatype/datatype_registry.ml

···
+type t = { datatypes : (string, Datatype.t) Hashtbl.t }
+
+let create () = { datatypes = Hashtbl.create 16 }
+
+let register t dt =
+  let name = Datatype.name dt in
+  Hashtbl.replace t.datatypes name dt
+
+let get t name = Hashtbl.find_opt t.datatypes name
+
+let list_names t =
+  Hashtbl.fold (fun name _ acc -> name :: acc) t.datatypes []
+  |> List.sort String.compare
+
+let default =
+  let registry = ref None in
+  fun () ->
+    match !registry with
+    | Some r -> r
+    | None ->
+        let r = create () in
+        (* Register built-in datatypes *)
+        register r (module Dt_integer.Integer : Datatype.S);
+        register r (module Dt_integer.Integer_non_negative : Datatype.S);
+        register r (module Dt_integer.Integer_positive : Datatype.S);
+        register r (module Dt_float.Float_ : Datatype.S);
+        register r (module Dt_float.Float_non_negative : Datatype.S);
+        register r (module Dt_float.Float_positive : Datatype.S);
+        register r (module Dt_boolean.Boolean : Datatype.S);
+        registry := Some r;
+        r

lib/html5_checker/datatype/datatype_registry.mli

···
+(** Registry for HTML5 datatypes *)
+
+(** Registry type that holds datatypes indexed by name *)
+type t
+
+(** Create a new empty registry *)
+val create : unit -> t
+
+(** Register a datatype in the registry *)
+val register : t -> Datatype.t -> unit
+
+(** Get a datatype by name. Returns None if not found *)
+val get : t -> string -> Datatype.t option
+
+(** List all registered datatype names *)
+val list_names : t -> string list
+
+(** Default registry with all built-in datatypes *)
+val default : unit -> t

lib/html5_checker/datatype/dt_autocomplete.ml

···
+(** Autocomplete attribute validation based on HTML5 spec *)
+
+(** Check if character is whitespace *)
+let is_whitespace c = c = ' ' || c = '\t' || c = '\n' || c = '\r'
+
+(** Convert character to ASCII lowercase *)
+let to_ascii_lowercase c =
+  if c >= 'A' && c <= 'Z' then Char.chr (Char.code c + 32) else c
+
+(** Trim whitespace from string *)
+let trim_whitespace s =
+  let s = String.trim s in
+  (* Also collapse internal whitespace *)
+  let buf = Buffer.create (String.length s) in
+  let in_space = ref false in
+  String.iter
+    (fun c ->
+      if is_whitespace c then
+        if not !in_space then (
+          Buffer.add_char buf ' ';
+          in_space := true)
+      else (
+        Buffer.add_char buf (to_ascii_lowercase c);
+        in_space := false))
+    s;
+  Buffer.contents buf
+
+(** Contact type tokens *)
+let contact_types = [ "home"; "work"; "mobile"; "fax"; "pager" ]
+
+(** All autofill field names *)
+let all_field_names =
+  [
+    "name";
+    "honorific-prefix";
+    "given-name";
+    "additional-name";
+    "family-name";
+    "honorific-suffix";
+    "nickname";
+    "organization-title";
+    "username";
+    "new-password";
+    "current-password";
+    "one-time-code";
+    "organization";
+    "street-address";
+    "address-line1";
+    "address-line2";
+    "address-line3";
+    "address-level4";
+    "address-level3";
+    "address-level2";
+    "address-level1";
+    "country";
+    "country-name";
+    "postal-code";
+    "cc-name";
+    "cc-given-name";
+    "cc-additional-name";
+    "cc-family-name";
+    "cc-number";
+    "cc-exp";
+    "cc-exp-month";
+    "cc-exp-year";
+    "cc-csc";
+    "cc-type";
+    "transaction-currency";
+    "transaction-amount";
+    "language";
+    "bday";
+    "bday-day";
+    "bday-month";
+    "bday-year";
+    "sex";
+    "url";
+    "photo";
+    "tel";
+    "tel-country-code";
+    "tel-national";
+    "tel-area-code";
+    "tel-local";
+    "tel-local-prefix";
+    "tel-local-suffix";
+    "tel-extension";
+    "email";
+    "impp";
+  ]
+
+(** Contact field names (subset that can be used with contact types) *)
+let contact_field_names =
+  [
+    "tel";
+    "tel-country-code";
+    "tel-national";
+    "tel-area-code";
+    "tel-local";
+    "tel-local-prefix";
+    "tel-local-suffix";
+    "tel-extension";
+    "email";
+    "impp";
+  ]
+
+(** Split string on whitespace *)
+let split_on_whitespace s =
+  let rec split acc start i =
+    if i >= String.length s then
+      if start < i then List.rev (String.sub s start (i - start) :: acc)
+      else List.rev acc
+    else if is_whitespace s.[i] then
+      if start < i then
+        split (String.sub s start (i - start) :: acc) (i + 1) (i + 1)
+      else split acc (i + 1) (i + 1)
+    else split acc start (i + 1)
+  in
+  split [] 0 0
+
+(** Check if string starts with prefix *)
+let starts_with s prefix =
+  String.length s >= String.length prefix
+  && String.sub s 0 (String.length prefix) = prefix
+
+(** Validate detail tokens *)
+let check_tokens tokens =
+  let tokens = ref tokens in
+  let is_contact_details = ref false in
+
+  (* Check for section-* *)
+  (match !tokens with
+  | token :: rest when starts_with token "section-" ->
+    tokens := rest
+  | _ -> ());
+
+  (* Check for shipping/billing *)
+  (match !tokens with
+  | "shipping" :: rest | "billing" :: rest ->
+    tokens := rest
+  | _ -> ());
+
+  (* Check for contact type *)
+  (match !tokens with
+  | token :: rest when List.mem token contact_types ->
+    tokens := rest;
+    is_contact_details := true
+  | _ -> ());
+
+  (* Process remaining tokens *)
+  let process_field_tokens = function
+    | [] -> Error "A list of autofill details tokens must contain an autofill field name"
+    | [ "webauthn" ] ->
+      Error
+        "The token \"webauthn\" must not be the only token in a list of \
+         autofill detail tokens"
+    | [ field_name ] ->
+      if not (List.mem field_name all_field_names) then
+        Error
+          (Printf.sprintf
+             "The string \"%s\" is not a valid autofill field name"
+             field_name)
+      else if !is_contact_details && not (List.mem field_name contact_field_names)
+      then
+        Error
+          (Printf.sprintf
+             "The autofill field name \"%s\" is not allowed in contact \
+              context"
+             field_name)
+      else Ok ()
+    | [ field_name; "webauthn" ] ->
+      if not (List.mem field_name all_field_names) then
+        Error
+          (Printf.sprintf
+             "The string \"%s\" is not a valid autofill field name"
+             field_name)
+      else if !is_contact_details && not (List.mem field_name contact_field_names)
+      then
+        Error
+          (Printf.sprintf
+             "The autofill field name \"%s\" is not allowed in contact \
+              context"
+             field_name)
+      else Ok ()
+    | token :: _ when List.mem token contact_types ->
+      Error
+        (Printf.sprintf
+           "The token \"%s\" must only appear before any autofill field names"
+           token)
+    | token :: _ when starts_with token "section-" ->
+      Error
+        "A \"section-*\" indicator must only appear as the first token in a \
+         list of autofill detail tokens"
+    | "shipping" :: _ | "billing" :: _ as toks ->
+      Error
+        (Printf.sprintf
+           "The token \"%s\" must only appear as either the first token in a \
+            list of autofill detail tokens, or, if the first token is a \
+            \"section-*\" indicator, as the second token"
+           (List.hd toks))
+    | _ :: "webauthn" :: _ :: _ ->
+      Error
+        "The token \"webauthn\" must only appear as the very last token in a \
+         list of autofill detail tokens"
+    | _ :: _ :: _ ->
+      Error
+        "A list of autofill details tokens must not contain more than one \
+         autofill field name"
+  in
+  process_field_tokens !tokens
+
+(** Validate autocomplete value *)
+let validate_autocomplete s =
+  let trimmed = trim_whitespace s in
+  if String.length trimmed = 0 then Error "Must not be empty"
+  else if trimmed = "on" || trimmed = "off" then Ok ()
+  else
+    let tokens = split_on_whitespace trimmed in
+    check_tokens tokens
+
+module Autocomplete = struct
+  let name = "autocomplete"
+  let validate = validate_autocomplete
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+let datatypes = [ (module Autocomplete : Datatype.S) ]

lib/html5_checker/datatype/dt_autocomplete.mli

···
+(** Autocomplete attribute datatype validator.
+
+    This module provides a validator for the autocomplete attribute used on
+    form fields, as defined by the HTML5 specification. *)
+
+(** Autocomplete attribute validator.
+
+    Validates autocomplete attribute values which can be:
+    - "on" or "off" (simple values)
+    - Autofill detail tokens in the format:
+      [section-*] [shipping|billing] [contact-type] field-name [webauthn]
+
+    Contact types: home, work, mobile, fax, pager
+
+    Field names include:
+    - Name fields: name, honorific-prefix, given-name, additional-name,
+      family-name, honorific-suffix, nickname, organization-title
+    - Authentication: username, new-password, current-password, one-time-code
+    - Organization: organization
+    - Address: street-address, address-line1, address-line2, address-line3,
+      address-level1, address-level2, address-level3, address-level4,
+      country, country-name, postal-code
+    - Credit card: cc-name, cc-given-name, cc-additional-name, cc-family-name,
+      cc-number, cc-exp, cc-exp-month, cc-exp-year, cc-csc, cc-type
+    - Transaction: transaction-currency, transaction-amount
+    - Other: language, bday, bday-day, bday-month, bday-year, sex, url, photo
+    - Contact: tel, tel-country-code, tel-national, tel-area-code, tel-local,
+      tel-local-prefix, tel-local-suffix, tel-extension, email, impp
+
+    Examples:
+    - "on"
+    - "off"
+    - "name"
+    - "email"
+    - "shipping street-address"
+    - "section-blue billing email"
+    - "work tel" *)
+module Autocomplete : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_boolean.ml

···
+(** Boolean attribute validation for HTML5 *)
+module Boolean = struct
+  let name = "boolean"
+
+  let validate s =
+    match s with
+    | "" | "true" | "false" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid boolean. Expected empty string, \
+              'true', or 'false'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+
+  let with_name attr_name =
+    let module M = struct
+      let name = "boolean"
+
+      let validate s =
+        match s with
+        | "" | "true" | "false" -> Ok ()
+        | _ ->
+            let s_lower = Datatype.string_to_ascii_lowercase s in
+            let attr_lower = Datatype.string_to_ascii_lowercase attr_name in
+            if s_lower = attr_lower then Ok ()
+            else
+              Error
+                (Printf.sprintf
+                   "The value '%s' is not a valid boolean. Expected empty \
+                    string, 'true', 'false', or '%s'."
+                   s attr_name)
+
+      let is_valid s = Result.is_ok (validate s)
+    end in
+    (module M : Datatype.S)
+end

lib/html5_checker/datatype/dt_boolean.mli

···
+(** Boolean attribute datatype validator for HTML5 *)
+
+(** Boolean attribute validation.
+
+    In HTML5, boolean attributes can have the following values:
+    - Empty string
+    - "true"
+    - "false"
+    - The attribute name itself (case-insensitive)
+
+    For attribute-name validation, use [Boolean.with_name]. *)
+module Boolean : sig
+  include Datatype.S
+
+  (** Create a boolean validator that also accepts a specific attribute name.
+      For example, [with_name "disabled"] will accept "", "true", "false", or
+      "disabled" (case-insensitive). *)
+  val with_name : string -> (module Datatype.S)
+end

lib/html5_checker/datatype/dt_button_type.ml

···
+(** Button type attribute validation based on HTML5 spec *)
+
+(** Valid button type values *)
+let valid_types = [ "submit"; "reset"; "button" ]
+
+module Button_type = struct
+  let name = "button-type"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_types then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid button type. Expected one of: %s."
+           s
+           (String.concat ", " valid_types))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Button_type : Datatype.S) ]

lib/html5_checker/datatype/dt_button_type.mli

···
+(** Button type attribute datatype validator.
+
+    This module provides a validator for the type attribute used on
+    button elements, as defined by the HTML5 specification. *)
+
+(** Button type attribute validator.
+
+    Validates button type attribute values which can be:
+    - submit - Submit button (submits the form)
+    - reset - Reset button (resets the form)
+    - button - Push button (no default behavior)
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "submit"
+    - "reset"
+    - "button" *)
+module Button_type : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_charset.ml

···
+(** Helper functions for charset validation *)
+
+let is_valid_charset_char c =
+  (c >= '0' && c <= '9') ||
+  (c >= 'a' && c <= 'z') ||
+  (c >= 'A' && c <= 'Z') ||
+  c = '-' || c = '!' || c = '#' || c = '$' || c = '%' || c = '&' ||
+  c = '\'' || c = '+' || c = '_' || c = '`' || c = '{' || c = '}' ||
+  c = '~' || c = '^'
+
+let to_lower s = String.lowercase_ascii s
+
+(** Common encoding labels recognized by WHATWG Encoding Standard.
+    This is a subset of the full list. *)
+let known_charsets = [
+  (* UTF-8 *)
+  "utf-8"; "utf8"; "unicode-1-1-utf-8";
+  (* Legacy single-byte encodings *)
+  "iso-8859-1"; "iso8859-1"; "latin1"; "iso-8859-2"; "iso-8859-3";
+  "iso-8859-4"; "iso-8859-5"; "iso-8859-6"; "iso-8859-7"; "iso-8859-8";
+  "iso-8859-9"; "iso-8859-10"; "iso-8859-13"; "iso-8859-14"; "iso-8859-15";
+  "iso-8859-16";
+  (* Windows code pages *)
+  "windows-1250"; "windows-1251"; "windows-1252"; "windows-1253";
+  "windows-1254"; "windows-1255"; "windows-1256"; "windows-1257";
+  "windows-1258";
+  (* Other common encodings *)
+  "us-ascii"; "ascii"; "utf-16"; "utf-16le"; "utf-16be";
+  "gb2312"; "gbk"; "gb18030"; "big5"; "euc-jp"; "iso-2022-jp";
+  "shift_jis"; "euc-kr"; "koi8-r"; "koi8-u";
+  (* Macintosh encodings *)
+  "macintosh"; "x-mac-roman";
+]
+
+(** Check if a charset name is recognized *)
+let is_known_charset name =
+  let lower = to_lower name in
+  List.mem lower known_charsets
+
+module Charset = struct
+  let name = "encoding name"
+
+  let validate s =
+    if String.length s = 0 then
+      Error "The empty string is not a valid character encoding name"
+    else
+      (* Check all characters are valid *)
+      let rec check_chars i =
+        if i >= String.length s then
+          Ok ()
+        else
+          let c = s.[i] in
+          if not (is_valid_charset_char c) then
+            Error (Printf.sprintf "Value contained '%c', which is not a valid character in an encoding name" c)
+          else
+            check_chars (i + 1)
+      in
+      match check_chars 0 with
+      | Error e -> Error e
+      | Ok () ->
+          let lower = to_lower s in
+          (* Reject "replacement" encoding *)
+          if lower = "replacement" then
+            Error (Printf.sprintf "'%s' is not a valid character encoding name" s)
+          (* Check if it's a known charset *)
+          else if not (is_known_charset lower) then
+            Error (Printf.sprintf "'%s' is not a valid character encoding name" s)
+          else
+            Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Meta_charset = struct
+  let name = "legacy character encoding declaration"
+
+  let is_whitespace c =
+    c = ' ' || c = '\t' || c = '\n' || c = '\012' || c = '\r'
+
+  let validate s =
+    let lower = to_lower s in
+    if not (String.starts_with ~prefix:"text/html;" lower) then
+      Error "The legacy encoding declaration did not start with 'text/html;'"
+    else if String.length lower = 10 then
+      Error "The legacy encoding declaration ended prematurely"
+    else
+      (* Skip whitespace after semicolon *)
+      let rec skip_ws i =
+        if i >= String.length lower then
+          Error "The legacy encoding declaration did not contain 'charset=' after the semicolon"
+        else
+          let c = lower.[i] in
+          if is_whitespace c then
+            skip_ws (i + 1)
+          else if c = 'c' then
+            Ok i
+          else
+            Error (Printf.sprintf "The legacy encoding declaration did not start with space characters or 'charset=' after the semicolon. Found '%c' instead" c)
+      in
+      match skip_ws 10 with
+      | Error e -> Error e
+      | Ok offset ->
+          if not (String.sub lower offset (String.length lower - offset) |> String.starts_with ~prefix:"charset=") then
+            Error "The legacy encoding declaration did not contain 'charset=' after the semicolon"
+          else
+            let charset_offset = offset + 8 in
+            if charset_offset >= String.length lower then
+              Error "The empty string is not a valid character encoding name"
+            else
+              (* Validate remaining characters *)
+              let rec check_chars i =
+                if i >= String.length lower then
+                  Ok ()
+                else
+                  let c = lower.[i] in
+                  if not (is_valid_charset_char c) then
+                    Error (Printf.sprintf "The legacy encoding contained '%c', which is not a valid character in an encoding name" c)
+                  else
+                    check_chars (i + 1)
+              in
+              match check_chars charset_offset with
+              | Error e -> Error e
+              | Ok () ->
+                  let encoding_name = String.sub lower charset_offset (String.length lower - charset_offset) in
+                  if encoding_name <> "utf-8" then
+                    Error "'charset=' must be followed by 'utf-8'"
+                  else
+                    Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [
+  (module Charset : Datatype.S);
+  (module Meta_charset : Datatype.S);
+]

lib/html5_checker/datatype/dt_charset.mli

···
+(** Character encoding datatype validators for HTML5.
+
+    This module provides validators for character encoding names as used in
+    HTML5. Encoding names must conform to the WHATWG Encoding Standard. *)
+
+(** Character encoding name datatype.
+
+    Validates a character encoding name according to the WHATWG Encoding
+    Standard. Valid encoding names include:
+    - UTF-8 (and variants like "utf-8", "utf8")
+    - Legacy encodings (ISO-8859-1, windows-1252, etc.)
+
+    The validator checks:
+    - Non-empty string
+    - Valid characters (alphanumeric, hyphen, and special chars: ! # $ % & ' + _ ` \{ \} ~ ^)
+    - Recognizes common encoding labels
+
+    Note: This is a simplified validator that recognizes common encoding
+    names but does not include the full WHATWG encoding label table.
+    It accepts labels case-insensitively. *)
+module Charset : Datatype.S
+
+(** Meta charset datatype for legacy encoding declarations.
+
+    Validates the charset attribute value in legacy meta elements of the form:
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+
+    The validator checks that:
+    - String starts with "text/html;"
+    - After optional whitespace, contains "charset="
+    - The charset value is "utf-8" (the only allowed value in modern HTML5)
+
+    Example valid value: "text/html; charset=utf-8" *)
+module Meta_charset : Datatype.S
+
+(** List of all charset datatypes *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_color.ml

···
+(** Color validation *)
+
+(** Named CSS colors *)
+let named_colors =
+  [
+    "aliceblue";
+    "antiquewhite";
+    "aqua";
+    "aquamarine";
+    "azure";
+    "beige";
+    "bisque";
+    "black";
+    "blanchedalmond";
+    "blue";
+    "blueviolet";
+    "brown";
+    "burlywood";
+    "cadetblue";
+    "chartreuse";
+    "chocolate";
+    "coral";
+    "cornflowerblue";
+    "cornsilk";
+    "crimson";
+    "cyan";
+    "darkblue";
+    "darkcyan";
+    "darkgoldenrod";
+    "darkgray";
+    "darkgrey";
+    "darkgreen";
+    "darkkhaki";
+    "darkmagenta";
+    "darkolivegreen";
+    "darkorange";
+    "darkorchid";
+    "darkred";
+    "darksalmon";
+    "darkseagreen";
+    "darkslateblue";
+    "darkslategray";
+    "darkslategrey";
+    "darkturquoise";
+    "darkviolet";
+    "deeppink";
+    "deepskyblue";
+    "dimgray";
+    "dimgrey";
+    "dodgerblue";
+    "firebrick";
+    "floralwhite";
+    "forestgreen";
+    "fuchsia";
+    "gainsboro";
+    "ghostwhite";
+    "gold";
+    "goldenrod";
+    "gray";
+    "grey";
+    "green";
+    "greenyellow";
+    "honeydew";
+    "hotpink";
+    "indianred";
+    "indigo";
+    "ivory";
+    "khaki";
+    "lavender";
+    "lavenderblush";
+    "lawngreen";
+    "lemonchiffon";
+    "lightblue";
+    "lightcoral";
+    "lightcyan";
+    "lightgoldenrodyellow";
+    "lightgray";
+    "lightgrey";
+    "lightgreen";
+    "lightpink";
+    "lightsalmon";
+    "lightseagreen";
+    "lightskyblue";
+    "lightslategray";
+    "lightslategrey";
+    "lightsteelblue";
+    "lightyellow";
+    "lime";
+    "limegreen";
+    "linen";
+    "magenta";
+    "maroon";
+    "mediumaquamarine";
+    "mediumblue";
+    "mediumorchid";
+    "mediumpurple";
+    "mediumseagreen";
+    "mediumslateblue";
+    "mediumspringgreen";
+    "mediumturquoise";
+    "mediumvioletred";
+    "midnightblue";
+    "mintcream";
+    "mistyrose";
+    "moccasin";
+    "navajowhite";
+    "navy";
+    "oldlace";
+    "olive";
+    "olivedrab";
+    "orange";
+    "orangered";
+    "orchid";
+    "palegoldenrod";
+    "palegreen";
+    "paleturquoise";
+    "palevioletred";
+    "papayawhip";
+    "peachpuff";
+    "peru";
+    "pink";
+    "plum";
+    "powderblue";
+    "purple";
+    "red";
+    "rosybrown";
+    "royalblue";
+    "saddlebrown";
+    "salmon";
+    "sandybrown";
+    "seagreen";
+    "seashell";
+    "sienna";
+    "silver";
+    "skyblue";
+    "slateblue";
+    "slategray";
+    "slategrey";
+    "snow";
+    "springgreen";
+    "steelblue";
+    "tan";
+    "teal";
+    "thistle";
+    "tomato";
+    "transparent";
+    "turquoise";
+    "violet";
+    "wheat";
+    "white";
+    "whitesmoke";
+    "yellow";
+    "yellowgreen";
+  ]
+
+(** Check if character is hex digit *)
+let is_hex_digit c =
+  (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
+
+(** Validate hex color (#RGB or #RRGGBB) *)
+let validate_hex_color s =
+  let len = String.length s in
+  if len <> 4 && len <> 7 then
+    Error "Hex color must be #RGB or #RRGGBB format"
+  else if s.[0] <> '#' then
+    Error "Hex color must start with '#'"
+  else
+    let rec check_hex i =
+      if i >= len then Ok ()
+      else if is_hex_digit s.[i] then check_hex (i + 1)
+      else
+        Error
+          (Printf.sprintf "Invalid hex digit '%c' at position %d" s.[i] i)
+    in
+    check_hex 1
+
+(** Simple color validator - strict #RRGGBB format *)
+module Simple_color = struct
+  let name = "simple color"
+
+  let validate s =
+    let s = String.trim s in
+    if String.length s <> 7 then
+      Error "Incorrect length for color string (must be 7 characters)"
+    else if s.[0] <> '#' then
+      Error
+        (Printf.sprintf
+           "Color starts with incorrect character '%c'. Expected the number \
+            sign '#'"
+           s.[0])
+    else
+      let rec check_hex i =
+        if i >= 7 then Ok ()
+        else if is_hex_digit s.[i] then check_hex (i + 1)
+        else
+          Error
+            (Printf.sprintf "'%c' is not a valid hexadecimal digit" s.[i])
+      in
+      check_hex 1
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+(** CSS color validator - supports multiple formats *)
+module Color = struct
+  let name = "color"
+
+  let validate s =
+    let s = String.trim s |> String.lowercase_ascii in
+    if String.length s = 0 then Error "Color value must not be empty"
+    else if List.mem s named_colors then Ok ()
+    else if String.length s > 0 && s.[0] = '#' then validate_hex_color s
+    else if
+      String.length s > 4
+      && (String.sub s 0 4 = "rgb(" || String.sub s 0 5 = "rgba(")
+    then
+      (* Basic validation for rgb/rgba - just check balanced parens *)
+      if s.[String.length s - 1] = ')' then Ok ()
+      else Error "rgb/rgba function must end with ')'"
+    else if
+      String.length s > 4
+      && (String.sub s 0 4 = "hsl(" || String.sub s 0 5 = "hsla(")
+    then
+      (* Basic validation for hsl/hsla - just check balanced parens *)
+      if s.[String.length s - 1] = ')' then Ok ()
+      else Error "hsl/hsla function must end with ')'"
+    else
+      Error
+        (Printf.sprintf
+           "Unrecognized color format '%s' (expected named color, hex, rgb(), \
+            rgba(), hsl(), or hsla())"
+           s)
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+let datatypes = [ (module Color : Datatype.S); (module Simple_color : Datatype.S) ]

lib/html5_checker/datatype/dt_color.mli

···
+(** Color value datatype validators.
+
+    This module provides validators for CSS color values and simple colors
+    as defined by the HTML5 specification. *)
+
+(** CSS color value validator.
+
+    Validates various CSS color formats:
+    - Named colors (e.g., "red", "blue", "transparent")
+    - Hex colors: #RGB or #RRGGBB
+    - rgb() and rgba() functional notation
+    - hsl() and hsla() functional notation
+
+    This is a simplified validator and does not validate all edge cases. *)
+module Color : Datatype.S
+
+(** Simple color validator (for input[type=color]).
+
+    Validates the simple color format:
+    - Must be exactly 7 characters
+    - Must start with '#'
+    - Followed by exactly 6 hexadecimal digits (0-9, a-f, A-F)
+    - Format: #RRGGBB
+
+    This is the strict format required for input[type=color]. *)
+module Simple_color : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_contenteditable.ml

···
+(** Contenteditable attribute validation for HTML5 *)
+
+module Contenteditable = struct
+  let name = "contenteditable"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "true" | "false" | "plaintext-only" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid contenteditable value. Expected \
+              'true', 'false', 'plaintext-only', or empty string."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Contenteditable : Datatype.S) ]

lib/html5_checker/datatype/dt_contenteditable.mli

···
+(** Contenteditable attribute datatype validator for HTML5.
+
+    This module provides a validator for the contenteditable attribute, as
+    defined by the HTML5 specification. *)
+
+(** Contenteditable attribute validator.
+
+    Validates contenteditable attribute values which can be:
+    - "true" - the element is editable
+    - "false" - the element is not editable
+    - "" (empty string) - equivalent to "true"
+    - "plaintext-only" - the element is editable, but rich text formatting is
+      disabled
+
+    Values are case-insensitive.
+
+    Examples:
+    - "true"
+    - "false"
+    - ""
+    - "plaintext-only" *)
+module Contenteditable : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_coords.ml

···
+(** Coordinates attribute validation for HTML5 *)
+
+module Coords = struct
+  let name = "coords"
+
+  let validate s =
+    (* Empty string is valid for default shape *)
+    if s = "" then Ok ()
+    else
+      (* Split on comma and validate each part is an integer *)
+      let parts =
+        String.split_on_char ',' s
+        |> List.map (fun p ->
+               let trimmed = String.trim p in
+               (* Check if it's a valid integer *)
+               try
+                 let _ = int_of_string trimmed in
+                 Ok ()
+               with Failure _ ->
+                 Error (Printf.sprintf "The value '%s' is not a valid integer" p))
+      in
+      (* Check if all parts are valid *)
+      let rec check = function
+        | [] -> Ok ()
+        | Ok () :: rest -> check rest
+        | (Error msg) :: _ -> Error msg
+      in
+      match check parts with
+      | Error msg ->
+          Error
+            (Printf.sprintf
+               "The coords value '%s' is not valid. %s. Expected a \
+                comma-separated list of integers."
+               s msg)
+      | Ok () -> (
+          (* Verify we have at least some values *)
+          let count = List.length parts in
+          match count with
+          | 0 -> Error "The coords value must not be empty unless for default shape"
+          | _ -> Ok ())
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Coords : Datatype.S) ]

lib/html5_checker/datatype/dt_coords.mli

···
+(** Coordinates attribute datatype validator for HTML5.
+
+    This module provides a validator for the coords attribute used on area
+    elements within image maps, as defined by the HTML5 specification. *)
+
+(** Coordinates attribute validator.
+
+    Validates coords attribute values which must be a comma-separated list of
+    valid integers. The number of values depends on the shape:
+    - rect: exactly 4 values (x1,y1,x2,y2)
+    - circle: exactly 3 values (x,y,radius)
+    - poly: even number of values >= 6 (x1,y1,x2,y2,x3,y3,...)
+    - default: should be empty or not present
+
+    Note: This validator only checks that the value is a valid comma-separated
+    list of integers. Shape-specific validation should be done at a higher level.
+
+    Examples:
+    - "0,0,10,10" (rect)
+    - "50,50,25" (circle)
+    - "0,0,50,0,50,50,0,50" (poly) *)
+module Coords : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_crossorigin.ml

···
+(** CORS crossorigin attribute validation for HTML5 *)
+
+module Crossorigin = struct
+  let name = "crossorigin"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "anonymous" | "use-credentials" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid crossorigin value. Expected \
+              empty string, 'anonymous', or 'use-credentials'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Crossorigin : Datatype.S) ]

lib/html5_checker/datatype/dt_crossorigin.mli

···
+(** CORS crossorigin attribute datatype validator.
+
+    This module provides a validator for the crossorigin attribute used on
+    script, link, img, audio, video elements, as defined by the HTML5 spec. *)
+
+(** Crossorigin attribute validator.
+
+    Validates crossorigin attribute values which can be:
+    - "" (empty string, equivalent to anonymous)
+    - "anonymous" (requests use CORS without credentials)
+    - "use-credentials" (requests use CORS with credentials)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "anonymous"
+    - "use-credentials"
+    - "Anonymous" (equivalent to "anonymous") *)
+module Crossorigin : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_datetime.ml

···
+(** Helper functions for datetime validation *)
+
+let is_digit c = c >= '0' && c <= '9'
+
+let is_all_digits s =
+  String.for_all is_digit s
+
+let parse_int s =
+  try Some (int_of_string s)
+  with Failure _ -> None
+
+(** Days in each month (non-leap year) *)
+let days_in_month = [| 31; 28; 31; 30; 31; 30; 31; 31; 30; 31; 30; 31 |]
+
+(** Check if a year is a leap year *)
+let is_leap_year year =
+  (year mod 400 = 0) || (year mod 4 = 0 && year mod 100 <> 0)
+
+(** Get maximum day for a given month/year *)
+let max_day_for_month year month =
+  if month = 2 && is_leap_year year then 29
+  else days_in_month.(month - 1)
+
+(** Years in the 400-year cycle that have 53 weeks *)
+let special_years_mod_400 = [|
+  4; 9; 15; 20; 26; 32; 37; 43; 48; 54; 60; 65; 71; 76; 82; 88; 93; 99;
+  105; 111; 116; 122; 128; 133; 139; 144; 150; 156; 161; 167; 172; 178;
+  184; 189; 195; 201; 207; 212; 218; 224; 229; 235; 240; 246; 252; 257;
+  263; 268; 274; 280; 285; 291; 296; 303; 308; 314; 320; 325; 331; 336;
+  342; 348; 353; 359; 364; 370; 376; 381; 387; 392; 398
+|]
+
+(** Check if a year has 53 weeks *)
+let has_53_weeks year =
+  let year_mod = year mod 400 in
+  Array.exists (fun y -> y = year_mod) special_years_mod_400
+
+module Year = struct
+  let name = "year"
+
+  let validate s =
+    let len = String.length s in
+    if len < 4 then
+      Error "Year must be at least 4 digits"
+    else if not (is_all_digits s) then
+      Error "Year must contain only digits"
+    else
+      match parse_int s with
+      | None -> Error "Year value out of range"
+      | Some year ->
+          if year < 1 then
+            Error "Year cannot be less than 1"
+          else
+            Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Month = struct
+  let name = "month"
+
+  let validate s =
+    if String.length s < 7 then
+      Error "Month must be in YYYY-MM format"
+    else
+      let pattern = Str.regexp "^\\([0-9]+\\)-\\([0-9][0-9]\\)$" in
+      if not (Str.string_match pattern s 0) then
+        Error "Month must be in YYYY-MM format"
+      else
+        let year_s = Str.matched_group 1 s in
+        let month_s = Str.matched_group 2 s in
+        match (parse_int year_s, parse_int month_s) with
+        | None, _ | _, None -> Error "Year or month out of range"
+        | Some year, Some month ->
+            if year < 1 then
+              Error "Year cannot be less than 1"
+            else if month < 1 then
+              Error "Month cannot be less than 1"
+            else if month > 12 then
+              Error "Month cannot be greater than 12"
+            else
+              Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Week = struct
+  let name = "week"
+
+  let validate s =
+    let pattern = Str.regexp "^\\([0-9]+\\)-W\\([0-9][0-9]\\)$" in
+    if not (Str.string_match pattern s 0) then
+      Error "Week must be in YYYY-Www format"
+    else
+      let year_s = Str.matched_group 1 s in
+      let week_s = Str.matched_group 2 s in
+      match (parse_int year_s, parse_int week_s) with
+      | None, _ | _, None -> Error "Year or week out of range"
+      | Some year, Some week ->
+          if year < 1 then
+            Error "Year cannot be less than 1"
+          else if week < 1 then
+            Error "Week cannot be less than 1"
+          else if week > 53 then
+            Error "Week out of range"
+          else if week = 53 && not (has_53_weeks year) then
+            Error "Week out of range"
+          else
+            Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Date = struct
+  let name = "date"
+
+  let validate s =
+    let pattern = Str.regexp "^\\([0-9]+\\)-\\([0-9][0-9]\\)-\\([0-9][0-9]\\)$" in
+    if not (Str.string_match pattern s 0) then
+      Error "Date must be in YYYY-MM-DD format"
+    else
+      let year_s = Str.matched_group 1 s in
+      let month_s = Str.matched_group 2 s in
+      let day_s = Str.matched_group 3 s in
+      if String.length year_s < 4 then
+        Error "Year must be at least 4 digits"
+      else
+        match (parse_int year_s, parse_int month_s, parse_int day_s) with
+        | None, _, _ | _, None, _ | _, _, None ->
+            Error "Year, month, or day out of range"
+        | Some year, Some month, Some day ->
+            if year < 1 then
+              Error "Year cannot be less than 1"
+            else if month < 1 then
+              Error "Month cannot be less than 1"
+            else if month > 12 then
+              Error "Month cannot be greater than 12"
+            else if day < 1 then
+              Error "Day cannot be less than 1"
+            else
+              let max_day = max_day_for_month year month in
+              if day > max_day then
+                Error "Day out of range"
+              else
+                Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Time = struct
+  let name = "time"
+
+  let validate s =
+    let pattern = Str.regexp "^\\([0-9][0-9]\\):\\([0-9][0-9]\\)\\(:\\([0-9][0-9]\\)\\(\\.\\([0-9]+\\)\\)?\\)?$" in
+    if not (Str.string_match pattern s 0) then
+      Error "Time must be in HH:MM[:SS[.sss]] format"
+    else
+      let hour_s = Str.matched_group 1 s in
+      let minute_s = Str.matched_group 2 s in
+      let second_s = try Some (Str.matched_group 4 s) with Not_found -> None in
+      let millis_s = try Some (Str.matched_group 6 s) with Not_found -> None in
+      match (parse_int hour_s, parse_int minute_s) with
+      | None, _ | _, None -> Error "Hour or minute out of range"
+      | Some hour, Some minute ->
+          if hour > 23 then
+            Error "Hour cannot be greater than 23"
+          else if minute > 59 then
+            Error "Minute cannot be greater than 59"
+          else
+            match second_s with
+            | None -> Ok ()
+            | Some sec_s ->
+                match parse_int sec_s with
+                | None -> Error "Seconds out of range"
+                | Some second ->
+                    if second > 59 then
+                      Error "Second cannot be greater than 59"
+                    else
+                      match millis_s with
+                      | None -> Ok ()
+                      | Some ms ->
+                          if String.length ms > 3 then
+                            Error "A fraction of a second must be one, two, or three digits"
+                          else if not (is_all_digits ms) then
+                            Error "Invalid milliseconds"
+                          else
+                            Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Datetime_local = struct
+  let name = "local datetime"
+
+  let validate s =
+    let pattern = Str.regexp "^\\(.+\\)[T ]\\(.+\\)$" in
+    if not (Str.string_match pattern s 0) then
+      Error "Datetime must be in YYYY-MM-DD[T ]HH:MM[:SS[.sss]] format"
+    else
+      let date_s = Str.matched_group 1 s in
+      let time_s = Str.matched_group 2 s in
+      match Date.validate date_s with
+      | Error e -> Error ("Invalid date: " ^ e)
+      | Ok () ->
+          match Time.validate time_s with
+          | Error e -> Error ("Invalid time: " ^ e)
+          | Ok () -> Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Datetime = struct
+  let name = "datetime"
+
+  let validate s =
+    if not (String.ends_with ~suffix:"Z" s) then
+      Error "Global datetime must end with 'Z'"
+    else
+      let s_without_z = String.sub s 0 (String.length s - 1) in
+      match Datetime_local.validate s_without_z with
+      | Error e -> Error e
+      | Ok () -> Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [
+  (module Year : Datatype.S);
+  (module Month : Datatype.S);
+  (module Week : Datatype.S);
+  (module Date : Datatype.S);
+  (module Time : Datatype.S);
+  (module Datetime_local : Datatype.S);
+  (module Datetime : Datatype.S);
+]

lib/html5_checker/datatype/dt_datetime.mli

···
+(** Date and time datatype validators for HTML5.
+
+    This module provides validators for various HTML5 date and time formats
+    as specified in the HTML5 standard. Each validator checks that strings
+    conform to the specific format and contain valid values. *)
+
+(** Year datatype (YYYY format, minimum 1).
+
+    Validates a year string consisting of 4 or more ASCII digits.
+    The year must be at least 1. *)
+module Year : Datatype.S
+
+(** Month datatype (YYYY-MM format).
+
+    Validates a month string in the format YYYY-MM where:
+    - YYYY is a valid year (>= 1)
+    - MM is a month from 01 to 12 *)
+module Month : Datatype.S
+
+(** Week datatype (YYYY-Www format).
+
+    Validates a week string in the format YYYY-Www where:
+    - YYYY is a valid year (>= 1)
+    - W is the literal character 'W'
+    - ww is a week number from 01 to 53
+
+    Week 53 is only valid for years that have 53 weeks in the ISO 8601
+    week-numbering calendar. *)
+module Week : Datatype.S
+
+(** Date datatype (YYYY-MM-DD format).
+
+    Validates a date string in the format YYYY-MM-DD where:
+    - YYYY is a valid year (>= 1)
+    - MM is a month from 01 to 12
+    - DD is a day valid for the given month/year
+
+    Handles leap years correctly. *)
+module Date : Datatype.S
+
+(** Time datatype (HH:MM[:SS[.sss]] format).
+
+    Validates a time string where:
+    - HH is hours from 00 to 23
+    - MM is minutes from 00 to 59
+    - SS (optional) is seconds from 00 to 59
+    - sss (optional) is milliseconds (1-3 digits)
+
+    Valid formats:
+    - HH:MM
+    - HH:MM:SS
+    - HH:MM:SS.s
+    - HH:MM:SS.ss
+    - HH:MM:SS.sss *)
+module Time : Datatype.S
+
+(** Local datetime datatype (YYYY-MM-DD[T ]HH:MM[:SS[.sss]] format).
+
+    Validates a local datetime string combining date and time with 'T' or
+    space separator. The date must be valid and the time must be valid.
+
+    This format does not include timezone information. *)
+module Datetime_local : Datatype.S
+
+(** Global datetime datatype (YYYY-MM-DD[T ]HH:MM[:SS[.sss]]Z format).
+
+    Validates a global datetime string in UTC (ending with 'Z').
+    The date must be valid and the time must be valid.
+
+    This is the format for datetime values that include timezone (UTC). *)
+module Datetime : Datatype.S
+
+(** List of all datetime datatypes *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_decoding.ml

···
+(** Image decoding attribute validation for HTML5 *)
+
+module Decoding = struct
+  let name = "decoding"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "sync" | "async" | "auto" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid decoding value. Expected empty \
+              string, 'sync', 'async', or 'auto'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Decoding : Datatype.S) ]

lib/html5_checker/datatype/dt_decoding.mli

···
+(** Image decoding attribute datatype validator.
+
+    This module provides a validator for the decoding attribute used to provide
+    a hint for image decoding, as defined by the HTML5 spec. *)
+
+(** Decoding attribute validator.
+
+    Validates decoding attribute values which can be:
+    - "" (empty string, default decoding behavior)
+    - "sync" (decode synchronously for atomic presentation)
+    - "async" (decode asynchronously to avoid delaying other content)
+    - "auto" (no preference for decoding mode)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "sync"
+    - "async"
+    - "auto" *)
+module Decoding : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_dir.ml

···
+(** Text direction attribute validation for HTML5 *)
+
+module Dir = struct
+  let name = "dir"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "ltr" | "rtl" | "auto" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid dir value. Expected empty \
+              string, 'ltr', 'rtl', or 'auto'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Dir : Datatype.S) ]

lib/html5_checker/datatype/dt_dir.mli

···
+(** Text direction attribute datatype validator.
+
+    This module provides a validator for the dir attribute used to specify
+    the text directionality of element content, as defined by the HTML5 spec. *)
+
+(** Dir attribute validator.
+
+    Validates dir attribute values which can be:
+    - "" (empty string, inherits directionality)
+    - "ltr" (left-to-right text direction)
+    - "rtl" (right-to-left text direction)
+    - "auto" (directionality determined from content)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "ltr"
+    - "rtl"
+    - "auto" *)
+module Dir : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_draggable.ml

···
+(** Draggable attribute validation for HTML5 *)
+
+module Draggable = struct
+  let name = "draggable"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "true" | "false" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid draggable value. Expected 'true' \
+              or 'false'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Draggable : Datatype.S) ]

lib/html5_checker/datatype/dt_draggable.mli

···
+(** Draggable attribute datatype validator for HTML5.
+
+    This module provides a validator for the draggable attribute, as defined by
+    the HTML5 specification. *)
+
+(** Draggable attribute validator.
+
+    Validates draggable attribute values which can be:
+    - "true" - the element is draggable
+    - "false" - the element is not draggable
+
+    Values are case-insensitive.
+
+    Examples:
+    - "true"
+    - "false" *)
+module Draggable : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_email.ml

···
+(** Email address validation *)
+
+(** Helper to check if a character is valid in email local/domain parts *)
+let is_email_char c =
+  (c >= 'a' && c <= 'z')
+  || (c >= 'A' && c <= 'Z')
+  || (c >= '0' && c <= '9')
+  || c = '.' || c = '-' || c = '_' || c = '+' || c = '='
+
+(** Validate a single email address using simplified rules *)
+let validate_email s =
+  let s = String.trim s in
+  if String.length s = 0 then Error "Email address must not be empty"
+  else
+    (* Check for exactly one @ symbol *)
+    let at_count = ref 0 in
+    let at_pos = ref (-1) in
+    String.iteri
+      (fun i c -> if c = '@' then (
+         incr at_count;
+         at_pos := i
+       ))
+      s;
+    if !at_count = 0 then Error "Email address must contain an '@' character"
+    else if !at_count > 1 then
+      Error "Email address must contain exactly one '@' character"
+    else
+      let local = String.sub s 0 !at_pos in
+      let domain = String.sub s (!at_pos + 1) (String.length s - !at_pos - 1) in
+
+      (* Validate local part *)
+      if String.length local = 0 then
+        Error "Email address must have a local part before '@'"
+      else if local.[0] = '.' || local.[String.length local - 1] = '.' then
+        Error "Email local part must not start or end with '.'"
+      else if not (String.for_all is_email_char local) then
+        Error "Email local part contains invalid characters"
+      else (* Validate domain part *)
+      if String.length domain = 0 then
+        Error "Email address must have a domain part after '@'"
+      else if not (String.contains domain '.') then
+        Error "Email domain must contain at least one '.'"
+      else if domain.[0] = '.' || domain.[String.length domain - 1] = '.' then
+        Error "Email domain must not start or end with '.'"
+      else if
+        not
+          (String.for_all
+             (fun c -> is_email_char c || c = '.')
+             domain)
+      then Error "Email domain contains invalid characters"
+      else Ok ()
+
+module Email = struct
+  let name = "email address"
+  let validate = validate_email
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+module Email_list = struct
+  let name = "email address list"
+
+  let validate s =
+    let s = String.trim s in
+    if String.length s = 0 then Error "Email list must not be empty"
+    else
+      (* Split on commas and validate each email *)
+      let emails = String.split_on_char ',' s in
+      let rec check_all = function
+        | [] -> Ok ()
+        | email :: rest -> (
+          match validate_email email with
+          | Ok () -> check_all rest
+          | Error msg ->
+            Error (Printf.sprintf "Invalid email in list: %s" msg))
+      in
+      check_all emails
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+let datatypes = [ (module Email : Datatype.S); (module Email_list : Datatype.S) ]

lib/html5_checker/datatype/dt_email.mli

···
+(** Email address datatype validators.
+
+    This module provides validators for email addresses and email address lists
+    as defined by the HTML5 specification. *)
+
+(** Valid email address validator.
+
+    Validates a single email address. Uses simplified validation rules:
+    - Must contain exactly one '@' character
+    - Local part (before @) must be non-empty
+    - Domain part (after @) must be non-empty and contain at least one '.'
+    - Only ASCII characters allowed *)
+module Email : Datatype.S
+
+(** Comma-separated email address list validator.
+
+    Validates a comma-separated list of email addresses.
+    Each address in the list must be valid according to {!Email} rules.
+    Whitespace around commas is ignored. *)
+module Email_list : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_enterkeyhint.ml

···
+(** Enter key hint attribute validation for HTML5 *)
+
+module Enterkeyhint = struct
+  let name = "enterkeyhint"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "enter" | "done" | "go" | "next" | "previous" | "search" | "send" ->
+        Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid enterkeyhint value. Expected \
+              one of: empty string, 'enter', 'done', 'go', 'next', \
+              'previous', 'search', or 'send'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Enterkeyhint : Datatype.S) ]

lib/html5_checker/datatype/dt_enterkeyhint.mli

···
+(** Enter key hint attribute datatype validator.
+
+    This module provides a validator for the enterkeyhint attribute used to
+    customize the enter key label on virtual keyboards, as defined by the HTML5 spec. *)
+
+(** Enterkeyhint attribute validator.
+
+    Validates enterkeyhint attribute values which can be:
+    - "" (empty string, default enter key)
+    - "enter" (insert new line)
+    - "done" (close input method editor)
+    - "go" (navigate to target)
+    - "next" (advance to next field)
+    - "previous" (go back to previous field)
+    - "search" (perform search)
+    - "send" (submit or deliver)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "done"
+    - "next"
+    - "search" *)
+module Enterkeyhint : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_fetchpriority.ml

···
+(** Fetch priority attribute validation for HTML5 *)
+
+module Fetchpriority = struct
+  let name = "fetchpriority"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "high" | "low" | "auto" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid fetchpriority value. Expected \
+              empty string, 'high', 'low', or 'auto'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Fetchpriority : Datatype.S) ]

lib/html5_checker/datatype/dt_fetchpriority.mli

···
+(** Fetch priority attribute datatype validator.
+
+    This module provides a validator for the fetchpriority attribute used to
+    provide a hint for resource fetch priority, as defined by the HTML5 spec. *)
+
+(** Fetchpriority attribute validator.
+
+    Validates fetchpriority attribute values which can be:
+    - "" (empty string, default fetch priority)
+    - "high" (fetch at high priority relative to other resources)
+    - "low" (fetch at low priority relative to other resources)
+    - "auto" (no preference for fetch priority)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "high"
+    - "low"
+    - "auto" *)
+module Fetchpriority : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_float.ml

···
+(** Valid HTML5 floating point number *)
+module Float_ = struct
+  let name = "floating point number"
+
+  type state =
+    | At_start
+    | At_start_minus_seen
+    | In_integer_part_digits_seen
+    | Dot_seen
+    | E_seen
+    | In_decimal_part_digits_seen
+    | In_exponent_sign_seen
+    | In_exponent_digits_seen
+
+  let validate s =
+    let len = String.length s in
+    let rec parse i state =
+      if i >= len then
+        match state with
+        | In_integer_part_digits_seen | In_decimal_part_digits_seen
+        | In_exponent_digits_seen ->
+            Ok ()
+        | At_start -> Error "The empty string is not a valid floating point number."
+        | At_start_minus_seen ->
+            Error "The minus sign alone is not a valid floating point number."
+        | Dot_seen ->
+            Error "A floating point number must not end with the decimal point."
+        | E_seen ->
+            Error "A floating point number must not end with the exponent 'e'."
+        | In_exponent_sign_seen ->
+            Error
+              "A floating point number must not end with only a sign in the \
+               exponent."
+      else
+        let c = s.[i] in
+        match state with
+        | At_start ->
+            if c = '-' then parse (i + 1) At_start_minus_seen
+            else if c = '.' then parse (i + 1) Dot_seen
+            else if Datatype.is_ascii_digit c then
+              parse (i + 1) In_integer_part_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a minus sign or a digit but saw '%c' instead." c)
+        | At_start_minus_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_integer_part_digits_seen
+            else Error (Printf.sprintf "Expected a digit but saw '%c' instead." c)
+        | In_integer_part_digits_seen ->
+            if c = '.' then parse (i + 1) Dot_seen
+            else if c = 'e' || c = 'E' then parse (i + 1) E_seen
+            else if Datatype.is_ascii_digit c then
+              parse (i + 1) In_integer_part_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a decimal point, 'e', 'E' or a digit but saw '%c' \
+                    instead."
+                   c)
+        | Dot_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_decimal_part_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a digit after the decimal point but saw '%c' instead."
+                   c)
+        | In_decimal_part_digits_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_decimal_part_digits_seen
+            else if c = 'e' || c = 'E' then parse (i + 1) E_seen
+            else
+              Error
+                (Printf.sprintf "Expected 'e', 'E' or a digit but saw '%c' instead."
+                   c)
+        | E_seen ->
+            if c = '-' || c = '+' then parse (i + 1) In_exponent_sign_seen
+            else if Datatype.is_ascii_digit c then
+              parse (i + 1) In_exponent_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a minus sign, a plus sign or a digit but saw '%c' \
+                    instead."
+                   c)
+        | In_exponent_sign_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_exponent_digits_seen
+            else Error (Printf.sprintf "Expected a digit but saw '%c' instead." c)
+        | In_exponent_digits_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_exponent_digits_seen
+            else Error (Printf.sprintf "Expected a digit but saw '%c' instead." c)
+    in
+    parse 0 At_start
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Non-negative floating point number (>= 0) *)
+module Float_non_negative = struct
+  let name = "non-negative floating point number"
+
+  type state =
+    | At_start
+    | At_start_minus_seen
+    | In_integer_part_digits_seen
+    | In_integer_part_digits_seen_zero
+    | Dot_seen
+    | Dot_seen_zero
+    | E_seen
+    | In_decimal_part_digits_seen
+    | In_decimal_part_digits_seen_zero
+    | In_exponent_sign_seen
+    | In_exponent_digits_seen
+
+  let validate s =
+    let len = String.length s in
+    let rec parse i state =
+      if i >= len then
+        match state with
+        | In_integer_part_digits_seen | In_decimal_part_digits_seen
+        | In_integer_part_digits_seen_zero | In_decimal_part_digits_seen_zero
+        | In_exponent_digits_seen ->
+            Ok ()
+        | At_start ->
+            Error "The empty string is not a valid non-negative floating point number."
+        | At_start_minus_seen ->
+            Error
+              "The minus sign alone is not a valid non-negative floating point \
+               number."
+        | Dot_seen | Dot_seen_zero ->
+            Error
+              "A non-negative floating point number must not end with the \
+               decimal point."
+        | E_seen ->
+            Error
+              "A non-negative floating point number must not end with the \
+               exponent 'e'."
+        | In_exponent_sign_seen ->
+            Error
+              "A non-negative floating point number must not end with only a \
+               sign in the exponent."
+      else
+        let c = s.[i] in
+        match state with
+        | At_start ->
+            if c = '-' then parse (i + 1) At_start_minus_seen
+            else if c = '.' then parse (i + 1) Dot_seen
+            else if Datatype.is_ascii_digit c then
+              parse (i + 1) In_integer_part_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a minus sign or a digit but saw '%c' instead." c)
+        | At_start_minus_seen ->
+            if c = '0' then parse (i + 1) In_integer_part_digits_seen_zero
+            else Error (Printf.sprintf "Expected a zero but saw '%c' instead." c)
+        | In_integer_part_digits_seen ->
+            if c = '.' then parse (i + 1) Dot_seen
+            else if c = 'e' || c = 'E' then parse (i + 1) E_seen
+            else if Datatype.is_ascii_digit c then
+              parse (i + 1) In_integer_part_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a decimal point, 'e', 'E' or a digit but saw '%c' \
+                    instead."
+                   c)
+        | In_integer_part_digits_seen_zero ->
+            if c = '.' then parse (i + 1) Dot_seen_zero
+            else if c = 'e' || c = 'E' then parse (i + 1) E_seen
+            else if c = '0' then parse (i + 1) In_integer_part_digits_seen_zero
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a decimal point, 'e', 'E' or a zero but saw '%c' \
+                    instead."
+                   c)
+        | Dot_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_decimal_part_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a digit after the decimal point but saw '%c' instead."
+                   c)
+        | Dot_seen_zero ->
+            if c = '0' then parse (i + 1) In_decimal_part_digits_seen_zero
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a zero after the decimal point but saw '%c' instead."
+                   c)
+        | In_decimal_part_digits_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_decimal_part_digits_seen
+            else if c = 'e' || c = 'E' then parse (i + 1) E_seen
+            else
+              Error
+                (Printf.sprintf "Expected 'e', 'E' or a digit but saw '%c' instead."
+                   c)
+        | In_decimal_part_digits_seen_zero ->
+            if c = '0' then parse (i + 1) In_decimal_part_digits_seen_zero
+            else if c = 'e' || c = 'E' then parse (i + 1) E_seen
+            else
+              Error
+                (Printf.sprintf "Expected 'e', 'E' or a zero but saw '%c' instead."
+                   c)
+        | E_seen ->
+            if c = '-' || c = '+' then parse (i + 1) In_exponent_sign_seen
+            else if Datatype.is_ascii_digit c then
+              parse (i + 1) In_exponent_digits_seen
+            else
+              Error
+                (Printf.sprintf
+                   "Expected a minus sign, a plus sign or a digit but saw '%c' \
+                    instead."
+                   c)
+        | In_exponent_sign_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_exponent_digits_seen
+            else Error (Printf.sprintf "Expected a digit but saw '%c' instead." c)
+        | In_exponent_digits_seen ->
+            if Datatype.is_ascii_digit c then
+              parse (i + 1) In_exponent_digits_seen
+            else Error (Printf.sprintf "Expected a digit but saw '%c' instead." c)
+    in
+    parse 0 At_start
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Positive floating point number (> 0) *)
+module Float_positive = struct
+  let name = "positive floating point number"
+
+  (* For positive floats, we validate it's a valid non-negative float,
+     then check it's not zero *)
+  let validate s =
+    match Float_non_negative.validate s with
+    | Error _ as e -> e
+    | Ok () -> (
+        (* Parse as float and check if it's positive *)
+        try
+          let f = float_of_string s in
+          if f > 0.0 then Ok ()
+          else Error "The value must be a positive floating point number."
+        with Failure _ ->
+          Error "Invalid floating point number format.")
+
+  let is_valid s = Result.is_ok (validate s)
+end

lib/html5_checker/datatype/dt_float.mli

···
+(** Floating point datatype validators for HTML5 *)
+
+(** Valid HTML5 floating point number *)
+module Float_ : sig
+  include Datatype.S
+end
+
+(** Non-negative floating point number (>= 0) *)
+module Float_non_negative : sig
+  include Datatype.S
+end
+
+(** Positive floating point number (> 0) *)
+module Float_positive : sig
+  include Datatype.S
+end

lib/html5_checker/datatype/dt_form_enctype.ml

···
+(** Form encoding type attribute validation based on HTML5 spec *)
+
+(** Valid form enctype values *)
+let valid_enctypes =
+  [
+    "application/x-www-form-urlencoded";
+    "multipart/form-data";
+    "text/plain";
+  ]
+
+module Form_enctype = struct
+  let name = "form-enctype"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_enctypes then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid form encoding type. Expected one of: \
+            %s."
+           s
+           (String.concat ", " valid_enctypes))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Form_enctype : Datatype.S) ]

lib/html5_checker/datatype/dt_form_enctype.mli

···
+(** Form encoding type attribute datatype validator.
+
+    This module provides a validator for the enctype and formenctype attributes
+    used on form and input/button elements, as defined by the HTML5 specification. *)
+
+(** Form encoding type attribute validator.
+
+    Validates form enctype/formenctype attribute values which can be:
+    - application/x-www-form-urlencoded - Default encoding (form fields as name=value pairs)
+    - multipart/form-data - Multipart encoding (required for file uploads)
+    - text/plain - Plain text encoding (mostly for debugging)
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "application/x-www-form-urlencoded"
+    - "multipart/form-data"
+    - "text/plain" *)
+module Form_enctype : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_form_method.ml

···
+(** Form method attribute validation based on HTML5 spec *)
+
+(** Valid form method values *)
+let valid_methods = [ "get"; "post"; "dialog" ]
+
+module Form_method = struct
+  let name = "form-method"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_methods then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid form method. Expected one of: %s."
+           s
+           (String.concat ", " valid_methods))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Form_method : Datatype.S) ]

lib/html5_checker/datatype/dt_form_method.mli

···
+(** Form method attribute datatype validator.
+
+    This module provides a validator for the method attribute used on
+    form elements, as defined by the HTML5 specification. *)
+
+(** Form method attribute validator.
+
+    Validates form method attribute values which can be:
+    - get - GET method (form data submitted in URL query string)
+    - post - POST method (form data submitted in request body)
+    - dialog - Dialog method (closes the dialog containing the form)
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "get"
+    - "post"
+    - "dialog" *)
+module Form_method : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_hash.ml

···
+(** Hash-name and fragment identifier datatype validators for HTML5. *)
+
+module Hash_name : Datatype.S = struct
+  let name = "hash-name reference"
+
+  let validate s =
+    let len = String.length s in
+    if len = 0 then Error "The empty string is not a valid hash-name reference."
+    else if s.[0] <> '#' then
+      Error "A hash-name reference must start with \"#\"."
+    else if len = 1 then
+      Error "A hash-name reference must have at least one character after \"#\"."
+    else Ok ()
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Hash_or_empty : Datatype.S = struct
+  let name = "hash-name reference (potentially empty)"
+
+  let validate s =
+    if String.length s = 0 then Ok ()
+    else Hash_name.validate s
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [ (module Hash_name : Datatype.S); (module Hash_or_empty : Datatype.S) ]

lib/html5_checker/datatype/dt_hash.mli

···
+(** Hash-name and fragment identifier datatype validators for HTML5.
+
+    This module provides validators for fragment identifiers (hash-name
+    references) used in URLs to reference specific parts of a document. *)
+
+(** Hash-name reference validator.
+
+    A hash-name reference is a fragment identifier that starts with '#'
+    followed by one or more characters.
+
+    Requirements:
+    - Must not be empty
+    - Must start with '#'
+    - Must have at least one character after '#' *)
+module Hash_name : Datatype.S
+
+(** Hash-name or empty validator.
+
+    Same as Hash_name but allows empty strings. This is used for attributes
+    where the hash-name reference is optional. *)
+module Hash_or_empty : Datatype.S
+
+(** List of all hash-related datatypes for registration. *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_hidden.ml

···
+(** Hidden attribute validation for HTML5 *)
+
+module Hidden = struct
+  let name = "hidden"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "hidden" | "until-found" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid hidden value. Expected 'hidden', \
+              'until-found', or empty string."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Hidden : Datatype.S) ]

lib/html5_checker/datatype/dt_hidden.mli

···
+(** Hidden attribute datatype validator for HTML5.
+
+    This module provides a validator for the hidden attribute, as defined by
+    the HTML5 specification. *)
+
+(** Hidden attribute validator.
+
+    Validates hidden attribute values which can be:
+    - "" (empty string) - the element is hidden
+    - "hidden" - the element is hidden
+    - "until-found" - the element is hidden until found by a find-in-page or
+      fragment navigation
+
+    Values are case-insensitive.
+
+    Examples:
+    - ""
+    - "hidden"
+    - "until-found" *)
+module Hidden : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_id.ml

···
+(** ID-related datatype validators for HTML5. *)
+
+module Id : Datatype.S = struct
+  let name = "id"
+
+  let validate s =
+    let len = String.length s in
+    if len = 0 then Error "An ID must not be the empty string."
+    else
+      match String.index_opt s ' ' with
+      | Some _ -> Error "An ID must not contain whitespace."
+      | None -> (
+          (* Check for other whitespace characters *)
+          let rec check_whitespace i =
+            if i >= len then Ok ()
+            else if Datatype.is_whitespace s.[i] then
+              Error "An ID must not contain whitespace."
+            else check_whitespace (i + 1)
+          in
+          check_whitespace 0)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Idref : Datatype.S = struct
+  let name = "id reference"
+
+  (* An IDREF has the same validation rules as an ID *)
+  let validate = Id.validate
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Idrefs : Datatype.S = struct
+  let name = "id references"
+
+  let validate s =
+    (* IDREFS must contain at least one non-whitespace character *)
+    let len = String.length s in
+    let rec check_non_whitespace i =
+      if i >= len then
+        Error "An IDREFS value must contain at least one non-whitespace character."
+      else if not (Datatype.is_whitespace s.[i]) then Ok ()
+      else check_non_whitespace (i + 1)
+    in
+    check_non_whitespace 0
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [ (module Id : Datatype.S)
+  ; (module Idref : Datatype.S)
+  ; (module Idrefs : Datatype.S)
+  ]

lib/html5_checker/datatype/dt_id.mli

···
+(** ID-related datatype validators for HTML5.
+
+    This module provides validators for HTML5 ID attributes and ID references
+    based on the Nu HTML Checker's implementation. *)
+
+(** ID validator.
+
+    Accepts any string that consists of one or more characters and does not
+    contain any whitespace characters.
+
+    An ID must be:
+    - Non-empty
+    - Contain no whitespace characters (space, tab, LF, FF, CR) *)
+module Id : Datatype.S
+
+(** ID reference validator.
+
+    An IDREF has the same validation rules as an ID - it must be non-empty
+    and contain no whitespace. The semantic difference is that an IDREF
+    references an existing ID rather than defining one. *)
+module Idref : Datatype.S
+
+(** ID references validator.
+
+    Accepts a space-separated list of ID references. The value must contain
+    at least one non-whitespace character.
+
+    IDREFS values:
+    - Must not be empty or contain only whitespace
+    - Can contain multiple space-separated ID references
+    - Each individual reference follows IDREF rules *)
+module Idrefs : Datatype.S
+
+(** List of all ID-related datatypes for registration. *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_input_type.ml

···
+(** Input type attribute validation based on HTML5 spec *)
+
+(** Valid input type values *)
+let valid_types =
+  [
+    "hidden";
+    "text";
+    "search";
+    "tel";
+    "url";
+    "email";
+    "password";
+    "date";
+    "month";
+    "week";
+    "time";
+    "datetime-local";
+    "number";
+    "range";
+    "color";
+    "checkbox";
+    "radio";
+    "file";
+    "submit";
+    "image";
+    "reset";
+    "button";
+  ]
+
+module Input_type = struct
+  let name = "input-type"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_types then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid input type. Expected one of: %s."
+           s
+           (String.concat ", " valid_types))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Input_type : Datatype.S) ]

lib/html5_checker/datatype/dt_input_type.mli

···
+(** Input type attribute datatype validator.
+
+    This module provides a validator for the type attribute used on
+    input elements, as defined by the HTML5 specification. *)
+
+(** Input type attribute validator.
+
+    Validates input type attribute values which can be:
+    - hidden - Hidden input field
+    - text - Single-line text field
+    - search - Search input field
+    - tel - Telephone number input field
+    - url - URL input field
+    - email - Email address input field
+    - password - Password input field
+    - date - Date input field (year, month, day)
+    - month - Month input field (year, month)
+    - week - Week input field (year, week)
+    - time - Time input field (hour, minute, seconds, fractional seconds)
+    - datetime-local - Local date and time input field
+    - number - Numeric input field
+    - range - Range control (slider)
+    - color - Color picker
+    - checkbox - Checkbox
+    - radio - Radio button
+    - file - File upload control
+    - submit - Submit button
+    - image - Image submit button
+    - reset - Reset button
+    - button - Push button
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "text"
+    - "email"
+    - "datetime-local"
+    - "submit" *)
+module Input_type : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_inputmode.ml

···
+(** Input mode attribute validation for HTML5 *)
+
+module Inputmode = struct
+  let name = "inputmode"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "none" | "text" | "decimal" | "numeric" | "tel" | "search"
+    | "email" | "url" ->
+        Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid inputmode value. Expected one \
+              of: empty string, 'none', 'text', 'decimal', 'numeric', 'tel', \
+              'search', 'email', or 'url'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Inputmode : Datatype.S) ]

lib/html5_checker/datatype/dt_inputmode.mli

···
+(** Input mode attribute datatype validator.
+
+    This module provides a validator for the inputmode attribute used to hint
+    at the type of data the user might enter, as defined by the HTML5 spec. *)
+
+(** Inputmode attribute validator.
+
+    Validates inputmode attribute values which can be:
+    - "" (empty string, no specific input mode)
+    - "none" (no virtual keyboard)
+    - "text" (standard text input)
+    - "decimal" (decimal numeric input with locale-appropriate format)
+    - "numeric" (numeric input)
+    - "tel" (telephone number input)
+    - "search" (search input)
+    - "email" (email address input)
+    - "url" (URL input)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "numeric"
+    - "email"
+    - "tel" *)
+module Inputmode : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_integer.ml

···
+(** Valid HTML5 integer (optional sign followed by digits) *)
+module Integer = struct
+  let name = "integer"
+
+  let validate s =
+    let len = String.length s in
+    if len = 0 then Error "The empty string is not a valid integer."
+    else
+      let start_pos =
+        if s.[0] = '-' then
+          if len = 1 then failwith "unreachable"
+          else 1
+        else 0
+      in
+      (* First character must be minus or digit *)
+      if start_pos = 0 && not (Datatype.is_ascii_digit s.[0]) then
+        Error
+          (Printf.sprintf "Expected a minus sign or a digit but saw '%c' instead."
+             s.[0])
+      else
+        (* Rest must be digits *)
+        let rec check_digits i =
+          if i >= len then Ok ()
+          else if Datatype.is_ascii_digit s.[i] then check_digits (i + 1)
+          else
+            Error (Printf.sprintf "Expected a digit but saw '%c' instead." s.[i])
+        in
+        check_digits start_pos
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Non-negative integer (>= 0) *)
+module Integer_non_negative = struct
+  let name = "non-negative integer"
+
+  let validate s =
+    let len = String.length s in
+    if len = 0 then Error "The empty string is not a valid non-negative integer."
+    else
+      (* All characters must be digits *)
+      let rec check_digits i =
+        if i >= len then Ok ()
+        else if Datatype.is_ascii_digit s.[i] then check_digits (i + 1)
+        else Error (Printf.sprintf "Expected a digit but saw '%c' instead." s.[i])
+      in
+      check_digits 0
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Positive integer (> 0) *)
+module Integer_positive = struct
+  let name = "positive integer"
+
+  let validate s =
+    let len = String.length s in
+    if len = 0 then Error "The empty string is not a valid positive integer."
+    else
+      (* All characters must be digits *)
+      let rec check_digits i all_zeros =
+        if i >= len then
+          if all_zeros then Error "Zero is not a positive integer." else Ok ()
+        else if Datatype.is_ascii_digit s.[i] then
+          check_digits (i + 1) (all_zeros && s.[i] = '0')
+        else Error (Printf.sprintf "Expected a digit but saw '%c' instead." s.[i])
+      in
+      check_digits 0 true
+
+  let is_valid s = Result.is_ok (validate s)
+end

lib/html5_checker/datatype/dt_integer.mli

···
+(** Integer datatype validators for HTML5 *)
+
+(** Valid HTML5 integer (optional sign followed by digits) *)
+module Integer : sig
+  include Datatype.S
+end
+
+(** Non-negative integer (>= 0) *)
+module Integer_non_negative : sig
+  include Datatype.S
+end
+
+(** Positive integer (> 0) *)
+module Integer_positive : sig
+  include Datatype.S
+end

lib/html5_checker/datatype/dt_integrity.ml

···
+(** Subresource integrity attribute validation *)
+
+(** Valid hash algorithms *)
+let valid_algorithms = [ "sha256"; "sha384"; "sha512" ]
+
+(** Check if character is valid base64 character *)
+let is_base64_char c =
+  (c >= 'A' && c <= 'Z')
+  || (c >= 'a' && c <= 'z')
+  || (c >= '0' && c <= '9')
+  || c = '+' || c = '/' || c = '='
+
+(** Validate base64 encoding *)
+let validate_base64 s =
+  if String.length s = 0 then false
+  else
+    (* Check all characters are valid base64 *)
+    let all_valid = ref true in
+    for i = 0 to String.length s - 1 do
+      if not (is_base64_char s.[i]) then all_valid := false
+    done;
+    if not !all_valid then false
+    else
+      (* Check padding is at the end only *)
+      let has_padding = String.contains s '=' in
+      if not has_padding then true
+      else
+        (* Find first '=' *)
+        let first_eq = String.index s '=' in
+        (* All chars after first '=' must be '=' *)
+        let valid_padding = ref true in
+        for i = first_eq to String.length s - 1 do
+          if s.[i] <> '=' then valid_padding := false
+        done;
+        !valid_padding
+        && (* At most 2 padding characters *)
+        String.length s - first_eq <= 2
+
+(** Validate a single hash value *)
+let validate_hash_value s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Hash value must not be empty"
+  else
+    (* Split on '-' to get algorithm and hash *)
+    match String.index_opt trimmed '-' with
+    | None ->
+        Error
+          (Printf.sprintf
+             "Hash value '%s' must be in format 'algorithm-base64hash'" trimmed)
+    | Some dash_pos ->
+        let algorithm = String.sub trimmed 0 dash_pos in
+        let algorithm_lower = Datatype.string_to_ascii_lowercase algorithm in
+        if not (List.mem algorithm_lower valid_algorithms) then
+          Error
+            (Printf.sprintf
+               "Hash algorithm '%s' is not supported. Must be one of: %s"
+               algorithm (String.concat ", " valid_algorithms))
+        else
+          let rest = String.sub trimmed (dash_pos + 1) (String.length trimmed - dash_pos - 1) in
+          (* Split on '?' to separate hash from options *)
+          let hash_part =
+            match String.index_opt rest '?' with
+            | None -> rest
+            | Some q_pos -> String.sub rest 0 q_pos
+          in
+          if String.length hash_part = 0 then
+            Error "Hash value after algorithm must not be empty"
+          else if not (validate_base64 hash_part) then
+            Error
+              (Printf.sprintf
+                 "Hash value '%s' is not valid base64 encoding" hash_part)
+          else Ok ()
+
+(** Validate integrity attribute value *)
+let validate_integrity s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Integrity attribute must not be empty"
+  else
+    (* Split on whitespace *)
+    let hash_values = String.split_on_char ' ' trimmed in
+    let hash_values =
+      List.filter (fun h -> Datatype.trim_html_spaces h <> "") hash_values
+    in
+    if hash_values = [] then
+      Error "Integrity attribute must contain at least one hash value"
+    else
+      (* Validate each hash value *)
+      let rec check_hashes = function
+        | [] -> Ok ()
+        | h :: rest -> (
+            match validate_hash_value h with
+            | Error e -> Error e
+            | Ok () -> check_hashes rest)
+      in
+      check_hashes hash_values
+
+module Integrity = struct
+  let name = "integrity"
+  let validate = validate_integrity
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Integrity : Datatype.S) ]

lib/html5_checker/datatype/dt_integrity.mli

···
+(** Subresource integrity attribute validator.
+
+    This module provides a validator for the integrity attribute used on
+    script and link elements for subresource integrity checks, as defined
+    by the W3C Subresource Integrity specification. *)
+
+(** Integrity attribute validator.
+
+    Validates integrity attribute values which contain space-separated hash
+    values. Each hash value consists of:
+    - An algorithm identifier (sha256, sha384, or sha512)
+    - A hyphen (-)
+    - The base64-encoded hash value
+    - Optional options preceded by '?'
+
+    Examples:
+    - "sha256-abc123..."
+    - "sha384-xyz789..."
+    - "sha256-abc123... sha512-def456..."
+    - "sha256-abc123...?ct=application/javascript"
+
+    The base64 encoding must be valid and the algorithm must be one of the
+    supported hash functions. *)
+module Integrity : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_kind.ml

···
+(** Kind attribute validation for HTML5 *)
+
+module Kind = struct
+  let name = "kind"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "subtitles" | "captions" | "descriptions" | "chapters" | "metadata" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid kind. Expected 'subtitles', \
+              'captions', 'descriptions', 'chapters', or 'metadata'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Kind : Datatype.S) ]

lib/html5_checker/datatype/dt_kind.mli

···
+(** Kind attribute datatype validator for HTML5.
+
+    This module provides a validator for the kind attribute used on track
+    elements, as defined by the HTML5 specification. *)
+
+(** Kind attribute validator.
+
+    Validates kind attribute values which can be:
+    - "subtitles" - Transcription or translation of the dialogue, suitable for
+      when the sound is available but not understood
+    - "captions" - Transcription or translation of the dialogue, sound effects,
+      relevant musical cues, and other relevant audio information, suitable for
+      when sound is unavailable or not clearly audible
+    - "descriptions" - Textual descriptions of the video component, suitable for
+      audio synthesis when the visual component is unavailable
+    - "chapters" - Chapter titles, for use in navigating the media resource
+    - "metadata" - Tracks intended for use from script, not displayed by the user
+      agent
+
+    Values are case-insensitive.
+
+    Examples:
+    - "subtitles"
+    - "captions"
+    - "descriptions" *)
+module Kind : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_language.ml

···
+(** Helper functions for language tag validation *)
+
+let is_lower_alpha c = c >= 'a' && c <= 'z'
+let is_upper_alpha c = c >= 'A' && c <= 'Z'
+let is_alpha c = is_lower_alpha c || is_upper_alpha c
+let is_digit c = c >= '0' && c <= '9'
+let is_alphanumeric c = is_alpha c || is_digit c
+
+let is_all_alpha s =
+  String.for_all is_alpha s
+
+let _is_all_digits s =
+  String.for_all is_digit s
+
+let is_all_alphanumeric s =
+  String.for_all is_alphanumeric s
+
+let to_lower s =
+  String.lowercase_ascii s
+
+(** Validate language tag structure according to BCP 47.
+    This is a simplified validator that checks structural validity
+    but does not validate against the IANA registry. *)
+let validate_language_structure s =
+  if String.length s = 0 then
+    Error "The empty string is not a valid language tag"
+  else if String.starts_with ~prefix:"-" s then
+    Error "Language tag must not start with HYPHEN-MINUS"
+  else if String.ends_with ~suffix:"-" s then
+    Error "Language tag must not end with HYPHEN-MINUS"
+  else
+    let subtags = String.split_on_char '-' s in
+
+    (* Check for empty subtags and length constraints *)
+    let rec check_subtag_constraints = function
+      | [] -> Ok ()
+      | subtag :: rest ->
+          let len = String.length subtag in
+          if len = 0 then
+            Error "Zero-length subtag"
+          else if len > 8 then
+            Error "Subtags must not exceed 8 characters in length"
+          else
+            check_subtag_constraints rest
+    in
+
+    match check_subtag_constraints subtags with
+    | Error e -> Error e
+    | Ok () ->
+        (* Primary language subtag validation *)
+        match subtags with
+        | [] -> Error "Language tag must have at least one subtag"
+        | first :: rest ->
+            let first_lower = to_lower first in
+            let len = String.length first_lower in
+
+            (* Check for private use tag *)
+            if first_lower = "x" then
+              if rest = [] then
+                Error "No subtags in private use sequence"
+              else
+                (* Private use subtags must be 1-8 alphanumeric *)
+                let rec check_private_use = function
+                  | [] -> Ok ()
+                  | subtag :: rest ->
+                      let subtag_lower = to_lower subtag in
+                      if String.length subtag_lower < 1 then
+                        Error "Private use subtag is too short"
+                      else if not (is_all_alphanumeric subtag_lower) then
+                        Error "Bad character in private use subtag"
+                      else
+                        check_private_use rest
+                in
+                check_private_use rest
+            (* Primary language: 2-3 letters (ISO 639) *)
+            else if (len = 2 || len = 3) && is_all_alpha first_lower then
+              Ok ()
+            (* Reserved: 4 letters *)
+            else if len = 4 && is_all_alpha first_lower then
+              Error "Found reserved language tag"
+            (* Registered: 5+ letters *)
+            else if len >= 5 && is_all_alpha first_lower then
+              Ok ()
+            else
+              Error "Invalid language subtag format"
+
+module Language = struct
+  let name = "language tag"
+
+  let validate s = validate_language_structure s
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Language_or_empty = struct
+  let name = "language tag or empty"
+
+  let validate s =
+    if String.length s = 0 then
+      Ok ()
+    else
+      validate_language_structure s
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [
+  (module Language : Datatype.S);
+  (module Language_or_empty : Datatype.S);
+]

lib/html5_checker/datatype/dt_language.mli

···
+(** Language tag datatype validators for HTML5.
+
+    This module provides validators for BCP 47 language tags as used in HTML5.
+    Language tags identify natural languages and consist of subtags separated
+    by hyphens, following the IETF BCP 47 standard. *)
+
+(** Language tag datatype (BCP 47 format).
+
+    Validates a language tag according to BCP 47. A language tag consists of:
+    - Primary language subtag (2-3 letters, or 5+ letters for registered languages)
+    - Optional extended language subtag (3 letters)
+    - Optional script subtag (4 letters)
+    - Optional region subtag (2 letters or 3 digits)
+    - Optional variant subtags (5-8 alphanumeric characters, or 4 starting with digit)
+    - Optional extension subtags (single letter + subtags)
+    - Optional private use subtags (starting with 'x-')
+
+    Examples:
+    - "en" (English)
+    - "en-US" (US English)
+    - "zh-Hans" (Simplified Chinese)
+    - "zh-Hans-CN" (Simplified Chinese as used in China)
+
+    The validator performs basic structural validation:
+    - Tag cannot be empty
+    - Tag cannot start or end with hyphen
+    - Subtags cannot be empty
+    - Subtags cannot exceed 8 characters (except for registered values)
+    - Primary language subtag must be 2-3 letters (ISO 639) or 5+ letters (registered)
+    - 4-letter primary subtags are reserved
+
+    Note: This implementation does NOT validate against the IANA language
+    subtag registry. It only validates the structural format. *)
+module Language : Datatype.S
+
+(** Language tag or empty string.
+
+    Like Language but also accepts the empty string. This is used for cases
+    where lang="" is valid to indicate an unknown or unspecified language. *)
+module Language_or_empty : Datatype.S
+
+(** List of all language datatypes *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_link_type.ml

···
+(** Link relationship type validation *)
+
+(** Valid link relationship types *)
+let valid_link_types =
+  [
+    "alternate";
+    "author";
+    "bookmark";
+    "canonical";
+    "dns-prefetch";
+    "external";
+    "help";
+    "icon";
+    "license";
+    "manifest";
+    "modulepreload";
+    "next";
+    "nofollow";
+    "noopener";
+    "noreferrer";
+    "opener";
+    "pingback";
+    "preconnect";
+    "prefetch";
+    "preload";
+    "prerender";
+    "prev";
+    "search";
+    "stylesheet";
+    "tag";
+  ]
+
+(** Validate a single link type *)
+let validate_link_type s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Link type must not be empty"
+  else
+    let lower = Datatype.string_to_ascii_lowercase trimmed in
+    if List.mem lower valid_link_types then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid link type. Valid link types are: %s"
+           s (String.concat ", " valid_link_types))
+
+module Link_type = struct
+  let name = "link-type"
+  let validate = validate_link_type
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Validate space-separated link types *)
+let validate_link_types s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Link types must not be empty"
+  else
+    (* Split on whitespace *)
+    let types = String.split_on_char ' ' trimmed in
+    let types = List.filter (fun t -> Datatype.trim_html_spaces t <> "") types in
+    if types = [] then Error "Link types must contain at least one link type"
+    else
+      (* Validate each link type *)
+      let rec check_types = function
+        | [] -> Ok ()
+        | t :: rest -> (
+            match validate_link_type t with
+            | Error e -> Error e
+            | Ok () -> check_types rest)
+      in
+      check_types types
+
+module Link_types = struct
+  let name = "link-types"
+  let validate = validate_link_types
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [ (module Link_type : Datatype.S); (module Link_types : Datatype.S) ]

lib/html5_checker/datatype/dt_link_type.mli

···
+(** Link relationship type validators.
+
+    This module provides validators for link relationship types used in rel
+    attributes on a and link elements, as defined by the HTML5 specification. *)
+
+(** Single link type validator.
+
+    Validates a single link relationship type value. Valid link types include:
+
+    - alternate: Alternate representation of the current document
+    - author: Link to author information
+    - bookmark: Permanent URL for nearest ancestor article
+    - canonical: Preferred URL for the current document
+    - dns-prefetch: Hint that the browser should prefetch DNS for the target
+    - external: Link to a different website
+    - help: Link to context-sensitive help
+    - icon: Icon representing the current document
+    - license: Copyright license for the current document
+    - manifest: Web app manifest
+    - modulepreload: Preload a JavaScript module
+    - next: Next document in a sequence
+    - nofollow: Do not follow this link for ranking
+    - noopener: Do not grant window.opener access
+    - noreferrer: Do not send Referer header
+    - opener: Grant window.opener access
+    - pingback: Pingback server address
+    - preconnect: Hint to preconnect to target origin
+    - prefetch: Hint to prefetch the target resource
+    - preload: Preload a resource
+    - prerender: Hint to prerender the target page
+    - prev: Previous document in a sequence
+    - search: Link to search tool for the current document
+    - stylesheet: External stylesheet
+    - tag: Tag (keyword) for the current document
+
+    Examples:
+    - "stylesheet"
+    - "icon"
+    - "preload"
+
+    Link types are case-insensitive. *)
+module Link_type : Datatype.S
+
+(** Space-separated link types validator.
+
+    Validates space-separated link relationship types. Multiple link types
+    can be specified separated by ASCII whitespace.
+
+    Examples:
+    - "stylesheet"
+    - "icon preload"
+    - "nofollow noopener noreferrer"
+
+    Each token must be a valid link type. Duplicate link types are allowed
+    but not recommended. *)
+module Link_types : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_list_type.ml

···
+(** List type attribute validation based on HTML5 spec *)
+
+(** Valid ol type values (case-sensitive) *)
+let valid_ol_types = [ "1"; "a"; "A"; "i"; "I" ]
+
+(** Valid ul type values (deprecated but still parsed) *)
+let valid_ul_types = [ "disc"; "circle"; "square" ]
+
+module Ol_type = struct
+  let name = "ol-type"
+
+  let validate s =
+    (* Note: ol type is case-sensitive *)
+    if List.mem s valid_ol_types then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid ol type. Expected one of: %s."
+           s
+           (String.concat ", " valid_ol_types))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Ul_type = struct
+  let name = "ul-type"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_ul_types then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid ul type. Expected one of: %s."
+           s
+           (String.concat ", " valid_ul_types))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [ (module Ol_type : Datatype.S); (module Ul_type : Datatype.S) ]

lib/html5_checker/datatype/dt_list_type.mli

···
+(** List type attribute datatype validators.
+
+    This module provides validators for the type attribute used on
+    ol and ul elements, as defined by the HTML5 specification. *)
+
+(** Ordered list type attribute validator.
+
+    Validates ol type attribute values which can be:
+    - 1 - Decimal numbers (1, 2, 3, ...)
+    - a - Lowercase Latin letters (a, b, c, ...)
+    - A - Uppercase Latin letters (A, B, C, ...)
+    - i - Lowercase Roman numerals (i, ii, iii, ...)
+    - I - Uppercase Roman numerals (I, II, III, ...)
+
+    Values are matched case-sensitively for ol type.
+
+    Examples:
+    - "1"
+    - "a"
+    - "A"
+    - "i"
+    - "I" *)
+module Ol_type : Datatype.S
+
+(** Unordered list type attribute validator.
+
+    Validates ul type attribute values which can be:
+    - disc - Filled circle (default)
+    - circle - Hollow circle
+    - square - Filled square
+
+    Note: The type attribute on ul is deprecated in HTML5 but may still
+    be parsed for backwards compatibility.
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "disc"
+    - "circle"
+    - "square" *)
+module Ul_type : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_loading.ml

···
+(** Lazy loading attribute validation for HTML5 *)
+
+module Loading = struct
+  let name = "loading"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "lazy" | "eager" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid loading value. Expected empty \
+              string, 'lazy', or 'eager'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Loading : Datatype.S) ]

lib/html5_checker/datatype/dt_loading.mli

···
+(** Lazy loading attribute datatype validator.
+
+    This module provides a validator for the loading attribute used to control
+    lazy loading behavior for images and iframes, as defined by the HTML5 spec. *)
+
+(** Loading attribute validator.
+
+    Validates loading attribute values which can be:
+    - "" (empty string, default loading behavior)
+    - "lazy" (defer loading until needed)
+    - "eager" (load immediately)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "lazy"
+    - "eager" *)
+module Loading : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_media_query.ml

···
+(** Media query validation - simplified implementation *)
+
+(** Media types *)
+let media_types =
+  [
+    "all";
+    "screen";
+    "print";
+    "speech";
+    "aural";
+    "braille";
+    "handheld";
+    "projection";
+    "tty";
+    "tv";
+    "embossed";
+  ]
+
+(** Media query keywords *)
+let media_keywords = [ "and"; "or"; "not"; "only" ]
+
+(** Check if character is whitespace *)
+let is_whitespace c = c = ' ' || c = '\t' || c = '\n' || c = '\r'
+
+(** Check if character can start an identifier *)
+let is_ident_start c =
+  (c >= 'a' && c <= 'z')
+  || (c >= 'A' && c <= 'Z')
+  || c = '_' || c = '-' || Char.code c >= 128
+
+(** Check if character can be in an identifier *)
+let is_ident_char c =
+  is_ident_start c || (c >= '0' && c <= '9')
+
+(** Check balanced parentheses *)
+let check_balanced_parens s =
+  let rec check depth i =
+    if i >= String.length s then
+      if depth = 0 then Ok ()
+      else Error "Unbalanced parentheses: unclosed '('"
+    else
+      let c = s.[i] in
+      match c with
+      | '(' -> check (depth + 1) (i + 1)
+      | ')' ->
+        if depth = 0 then Error "Unbalanced parentheses: unexpected ')'"
+        else check (depth - 1) (i + 1)
+      | _ -> check depth (i + 1)
+  in
+  check 0 0
+
+(** Extract words (identifiers and keywords) from media query *)
+let extract_words s =
+  let words = ref [] in
+  let buf = Buffer.create 16 in
+  let in_parens = ref 0 in
+
+  for i = 0 to String.length s - 1 do
+    let c = s.[i] in
+    match c with
+    | '(' ->
+      if Buffer.length buf > 0 then (
+        words := Buffer.contents buf :: !words;
+        Buffer.clear buf);
+      incr in_parens
+    | ')' ->
+      if Buffer.length buf > 0 then (
+        words := Buffer.contents buf :: !words;
+        Buffer.clear buf);
+      decr in_parens
+    | _ ->
+      if !in_parens = 0 then
+        if is_ident_char c then Buffer.add_char buf c
+        else if is_whitespace c then
+          if Buffer.length buf > 0 then (
+            words := Buffer.contents buf :: !words;
+            Buffer.clear buf)
+        else ()
+      else if Buffer.length buf > 0 then (
+        words := Buffer.contents buf :: !words;
+        Buffer.clear buf)
+  done;
+
+  if Buffer.length buf > 0 then words := Buffer.contents buf :: !words;
+  List.rev !words
+
+(** Validate media query structure *)
+let validate_media_query s =
+  let s = String.trim s in
+  if String.length s = 0 then Error "Media query must not be empty"
+  else
+    (* Check balanced parentheses *)
+    match check_balanced_parens s with
+    | Error _ as e -> e
+    | Ok () ->
+      (* Extract and validate words *)
+      let words = extract_words s in
+      let words_lower = List.map String.lowercase_ascii words in
+
+      (* Basic validation: check for invalid keyword combinations *)
+      let rec validate_words prev = function
+        | [] -> Ok ()
+        | word :: rest -> (
+          let word_lower = String.lowercase_ascii word in
+          match (prev, word_lower) with
+          | None, "and" | None, "or" ->
+            Error
+              (Printf.sprintf
+                 "Media query cannot start with keyword '%s'" word)
+          | Some "and", "and" | Some "or", "or" | Some "not", "not" ->
+            Error
+              (Printf.sprintf "Consecutive '%s' keywords are not allowed"
+                 word)
+          | Some "only", "only" ->
+            Error "Consecutive 'only' keywords are not allowed"
+          | _, _ -> validate_words (Some word_lower) rest)
+      in
+
+      (* Check if query contains valid media types or features *)
+      let has_media_type =
+        List.exists
+          (fun w -> List.mem (String.lowercase_ascii w) media_types)
+          words
+      in
+      let has_features = String.contains s '(' in
+
+      if not (has_media_type || has_features) then
+        (* Only keywords, no actual media type or features *)
+        if List.for_all (fun w -> List.mem w media_keywords) words_lower then
+          Error "Media query contains only keywords without media type or features"
+        else Ok () (* Assume other identifiers are valid *)
+      else validate_words None words
+
+module Media_query = struct
+  let name = "media query"
+  let validate = validate_media_query
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+let datatypes = [ (module Media_query : Datatype.S) ]

lib/html5_checker/datatype/dt_media_query.mli

···
+(** Media query datatype validator.
+
+    This module provides a validator for CSS media queries as used in HTML5. *)
+
+(** Media query validator.
+
+    Validates CSS media queries used in media attributes and CSS @media rules.
+
+    Examples:
+    - "screen"
+    - "print"
+    - "(min-width: 600px)"
+    - "screen and (color)"
+    - "not screen and (color)"
+    - "(min-width: 600px) and (max-width: 800px)"
+
+    This is a simplified validator that checks:
+    - Balanced parentheses
+    - Basic media type keywords (all, screen, print, etc.)
+    - Basic logical operators (and, or, not, only)
+    - Valid feature queries in parentheses
+
+    Note: This does not perform full CSS media query parsing. For production
+    use, consider integrating with a full CSS parser. *)
+module Media_query : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_mime.ml

···
+(** MIME type validation based on RFC 2045 and HTML5 spec *)
+
+(** Check if character is whitespace *)
+let is_whitespace c = c = ' ' || c = '\t' || c = '\n' || c = '\r'
+
+(** Check if character is a token character (RFC 2045) *)
+let is_token_char c =
+  (c >= '\033' && c <= '\126')
+  && not
+       (c = '(' || c = ')' || c = '<' || c = '>' || c = '@' || c = ','
+       || c = ';' || c = ':' || c = '\\' || c = '"' || c = '/' || c = '['
+       || c = ']' || c = '?' || c = '=' || c = '{' || c = '}')
+
+(** Check if character is valid in quoted string (qdtext) *)
+let is_qdtext_char c =
+  (c >= ' ' && c <= '\126') || c = '\n' || c = '\r' || c = '\t'
+
+(** States for MIME type parser *)
+type parse_state =
+  | At_start
+  | In_supertype
+  | At_subtype_start
+  | In_subtype
+  | Semicolon_seen
+  | Ws_before_semicolon
+  | In_param_name
+  | Equals_seen
+  | In_quoted_string
+  | In_unquoted_string
+  | In_quoted_pair
+  | Close_quote_seen
+
+(** JavaScript MIME types that should not have parameters *)
+let javascript_mime_types =
+  [
+    "application/ecmascript";
+    "application/javascript";
+    "application/x-ecmascript";
+    "application/x-javascript";
+    "text/ecmascript";
+    "text/javascript";
+    "text/javascript1.0";
+    "text/javascript1.1";
+    "text/javascript1.2";
+    "text/javascript1.3";
+    "text/javascript1.4";
+    "text/javascript1.5";
+    "text/jscript";
+    "text/livescript";
+    "text/x-ecmascript";
+    "text/x-javascript";
+  ]
+
+(** Validate a single MIME type *)
+let validate_mime_type s =
+  let len = String.length s in
+  let rec parse state i =
+    if i >= len then
+      (* End of string - check final state *)
+      match state with
+      | In_subtype | In_unquoted_string | Close_quote_seen -> Ok ()
+      | At_start -> Error "Expected a MIME type but saw the empty string"
+      | In_supertype | At_subtype_start -> Error "Subtype missing"
+      | Equals_seen | In_param_name -> Error "Parameter value missing"
+      | In_quoted_pair | In_quoted_string -> Error "Unfinished quoted string"
+      | Semicolon_seen ->
+        Error "Semicolon seen but there was no parameter following it"
+      | Ws_before_semicolon -> Error "Extraneous trailing whitespace"
+    else
+      let c = s.[i] in
+      match state with
+      | At_start ->
+        if is_token_char c then parse In_supertype (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a token character but saw '%c' instead" c)
+      | In_supertype ->
+        if is_token_char c then parse In_supertype (i + 1)
+        else if c = '/' then parse At_subtype_start (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a token character or '/' but saw '%c' instead" c)
+      | At_subtype_start ->
+        if is_token_char c then parse In_subtype (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a token character but saw '%c' instead" c)
+      | In_subtype ->
+        if is_token_char c then parse In_subtype (i + 1)
+        else if c = ';' then
+          (* Check if this is a JavaScript MIME type *)
+          let mime_type = String.sub s 0 i |> String.lowercase_ascii in
+          if List.mem mime_type javascript_mime_types then
+            Error
+              "A JavaScript MIME type must not contain any characters after \
+               the subtype"
+          else parse Semicolon_seen (i + 1)
+        else if is_whitespace c then parse Ws_before_semicolon (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a token character, whitespace or a semicolon but saw \
+                '%c' instead"
+               c)
+      | Ws_before_semicolon ->
+        if is_whitespace c then parse Ws_before_semicolon (i + 1)
+        else if c = ';' then parse Semicolon_seen (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected whitespace or a semicolon but saw '%c' instead" c)
+      | Semicolon_seen ->
+        if is_whitespace c then parse Semicolon_seen (i + 1)
+        else if is_token_char c then parse In_param_name (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected whitespace or a token character but saw '%c' instead"
+               c)
+      | In_param_name ->
+        if is_token_char c then parse In_param_name (i + 1)
+        else if c = '=' then parse Equals_seen (i + 1)
+        else
+          Error
+            (Printf.sprintf "Expected a token character or '=' but saw '%c' instead"
+               c)
+      | Equals_seen ->
+        if c = '"' then parse In_quoted_string (i + 1)
+        else if is_token_char c then parse In_unquoted_string (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a double quote or a token character but saw '%c' \
+                instead"
+               c)
+      | In_quoted_string ->
+        if c = '\\' then parse In_quoted_pair (i + 1)
+        else if c = '"' then parse Close_quote_seen (i + 1)
+        else if is_qdtext_char c then parse In_quoted_string (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a non-control ASCII character but saw '%c' instead" c)
+      | In_quoted_pair ->
+        if Char.code c <= 127 then parse In_quoted_string (i + 1)
+        else
+          Error
+            (Printf.sprintf "Expected an ASCII character but saw '%c' instead"
+               c)
+      | Close_quote_seen ->
+        if c = ';' then parse Semicolon_seen (i + 1)
+        else if is_whitespace c then parse Ws_before_semicolon (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a semicolon or whitespace but saw '%c' instead" c)
+      | In_unquoted_string ->
+        if is_token_char c then parse In_unquoted_string (i + 1)
+        else if c = ';' then parse Semicolon_seen (i + 1)
+        else if is_whitespace c then parse Ws_before_semicolon (i + 1)
+        else
+          Error
+            (Printf.sprintf
+               "Expected a token character, whitespace or a semicolon but saw \
+                '%c' instead"
+               c)
+  in
+  parse At_start 0
+
+module Mime_type = struct
+  let name = "MIME type"
+  let validate = validate_mime_type
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+module Mime_type_list = struct
+  let name = "MIME type list"
+
+  let validate s =
+    let s = String.trim s in
+    if String.length s = 0 then Error "MIME type list must not be empty"
+    else
+      (* Split on commas and validate each MIME type *)
+      let mime_types = String.split_on_char ',' s in
+      let rec check_all = function
+        | [] -> Ok ()
+        | mime :: rest -> (
+          let mime = String.trim mime in
+          match validate_mime_type mime with
+          | Ok () -> check_all rest
+          | Error msg ->
+            Error (Printf.sprintf "Invalid MIME type in list: %s" msg))
+      in
+      check_all mime_types
+
+  let is_valid s =
+    match validate s with
+    | Ok () -> true
+    | Error _ -> false
+end
+
+let datatypes =
+  [ (module Mime_type : Datatype.S); (module Mime_type_list : Datatype.S) ]

lib/html5_checker/datatype/dt_mime.mli

···
+(** MIME type datatype validators.
+
+    This module provides validators for MIME types (media types) as defined
+    by RFC 2045 and used in HTML5. *)
+
+(** MIME type validator.
+
+    Validates a MIME type in the format: type/subtype[; parameters]
+
+    Examples:
+    - text/html
+    - application/json
+    - image/png
+    - text/html; charset=utf-8
+
+    Validation rules:
+    - Must have a supertype (before /) and subtype (after /)
+    - Supertype and subtype must be token characters
+    - Optional semicolon-separated parameters
+    - Parameters must be name=value pairs
+    - Values can be quoted strings or tokens *)
+module Mime_type : Datatype.S
+
+(** MIME type list validator.
+
+    Validates a comma-separated list of MIME types.
+    Each MIME type in the list must be valid according to {!Mime_type} rules.
+    This is used for the 'accept' attribute on input elements. *)
+module Mime_type_list : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_popover.ml

···
+(** Popover attribute validation for HTML5 *)
+
+module Popover = struct
+  let name = "popover"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "auto" | "manual" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid popover value. Expected 'auto', \
+              'manual', or empty string."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Popover : Datatype.S) ]

lib/html5_checker/datatype/dt_popover.mli

···
+(** Popover attribute datatype validator for HTML5.
+
+    This module provides a validator for the popover attribute, as defined by
+    the HTML5 specification. *)
+
+(** Popover attribute validator.
+
+    Validates popover attribute values which can be:
+    - "auto" - the popover can be light-dismissed (closed by clicking outside)
+    - "manual" - the popover must be explicitly closed
+    - "" (empty string) - equivalent to "auto"
+
+    Values are case-insensitive.
+
+    Examples:
+    - "auto"
+    - "manual"
+    - "" *)
+module Popover : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_preload.ml

···
+(** Media preload attribute validation based on HTML5 spec *)
+
+(** Valid preload values *)
+let valid_preloads = [ "none"; "metadata"; "auto"; "" ]
+
+module Preload = struct
+  let name = "preload"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_preloads then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid preload value. Expected one of: \
+            'none', 'metadata', 'auto', or empty string."
+           s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Preload : Datatype.S) ]

lib/html5_checker/datatype/dt_preload.mli

···
+(** Media preload attribute datatype validator.
+
+    This module provides a validator for the preload attribute used on
+    audio and video elements, as defined by the HTML5 specification. *)
+
+(** Media preload attribute validator.
+
+    Validates media preload attribute values which can be:
+    - none - No preloading (only load metadata when user starts playback)
+    - metadata - Preload metadata only (dimensions, duration, etc.)
+    - auto - Preload the entire resource if possible
+    - "" (empty string) - Equivalent to auto
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "none"
+    - "metadata"
+    - "auto"
+    - "" *)
+module Preload : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_referrer.ml

···
+(** Referrer policy attribute validation for HTML5 *)
+
+module Referrer_policy = struct
+  let name = "referrerpolicy"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | ""
+    | "no-referrer"
+    | "no-referrer-when-downgrade"
+    | "origin"
+    | "origin-when-cross-origin"
+    | "same-origin"
+    | "strict-origin"
+    | "strict-origin-when-cross-origin"
+    | "unsafe-url" ->
+        Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid referrerpolicy value. Expected \
+              one of: empty string, 'no-referrer', \
+              'no-referrer-when-downgrade', 'origin', \
+              'origin-when-cross-origin', 'same-origin', 'strict-origin', \
+              'strict-origin-when-cross-origin', or 'unsafe-url'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Referrer_policy : Datatype.S) ]

lib/html5_checker/datatype/dt_referrer.mli

···
+(** Referrer policy attribute datatype validator.
+
+    This module provides a validator for the referrerpolicy attribute used to
+    control referrer information sent with requests, as defined by the HTML5 spec. *)
+
+(** Referrer policy attribute validator.
+
+    Validates referrerpolicy attribute values which can be:
+    - "" (empty string, uses default policy)
+    - "no-referrer" (never send referrer)
+    - "no-referrer-when-downgrade" (send referrer to same security level)
+    - "origin" (send origin only)
+    - "origin-when-cross-origin" (full URL for same-origin, origin for cross-origin)
+    - "same-origin" (send referrer for same-origin only)
+    - "strict-origin" (send origin for same security level)
+    - "strict-origin-when-cross-origin" (full URL same-origin, origin cross-origin same security)
+    - "unsafe-url" (always send full URL)
+
+    Values are case-insensitive after ASCII lowercasing.
+
+    Examples:
+    - ""
+    - "no-referrer"
+    - "origin"
+    - "strict-origin-when-cross-origin" *)
+module Referrer_policy : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_sandbox.ml

···
+(** Sandbox tokens validation *)
+
+(** Valid sandbox tokens (case-sensitive) *)
+let valid_sandbox_tokens =
+  [
+    "allow-downloads";
+    "allow-forms";
+    "allow-modals";
+    "allow-orientation-lock";
+    "allow-pointer-lock";
+    "allow-popups";
+    "allow-popups-to-escape-sandbox";
+    "allow-presentation";
+    "allow-same-origin";
+    "allow-scripts";
+    "allow-top-navigation";
+    "allow-top-navigation-by-user-activation";
+    "allow-top-navigation-to-custom-protocols";
+  ]
+
+(** Validate sandbox attribute value *)
+let validate_sandbox s =
+  let trimmed = Datatype.trim_html_spaces s in
+  (* Empty value is valid (maximum restrictions) *)
+  if trimmed = "" then Ok ()
+  else
+    (* Split on whitespace *)
+    let tokens = String.split_on_char ' ' trimmed in
+    let tokens = List.filter (fun t -> Datatype.trim_html_spaces t <> "") tokens in
+    if tokens = [] then Ok () (* All whitespace is like empty *)
+    else
+      (* Validate each token *)
+      let rec check_tokens = function
+        | [] -> Ok ()
+        | token :: rest ->
+            (* Sandbox tokens are case-sensitive *)
+            if List.mem token valid_sandbox_tokens then check_tokens rest
+            else
+              Error
+                (Printf.sprintf
+                   "The value '%s' is not a valid sandbox token. Valid tokens \
+                    are: %s"
+                   token (String.concat ", " valid_sandbox_tokens))
+      in
+      check_tokens tokens
+
+module Sandbox = struct
+  let name = "sandbox"
+  let validate = validate_sandbox
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Sandbox : Datatype.S) ]

lib/html5_checker/datatype/dt_sandbox.mli

···
+(** Sandbox tokens validator.
+
+    This module provides a validator for the sandbox attribute used on iframe
+    elements, as defined by the HTML5 specification. *)
+
+(** Sandbox attribute validator.
+
+    Validates sandbox attribute values which contain space-separated sandbox
+    tokens. Each token enables a specific capability for the sandboxed iframe.
+
+    Valid tokens:
+    - allow-downloads: Allow downloads
+    - allow-forms: Allow form submission
+    - allow-modals: Allow modal dialogs (alert, confirm, etc.)
+    - allow-orientation-lock: Allow orientation lock
+    - allow-pointer-lock: Allow pointer lock
+    - allow-popups: Allow popups (window.open, target="_blank", etc.)
+    - allow-popups-to-escape-sandbox: Allow popups that don't inherit sandboxing
+    - allow-presentation: Allow presentation sessions
+    - allow-same-origin: Allow same-origin access
+    - allow-scripts: Allow script execution
+    - allow-top-navigation: Allow navigating top-level browsing context
+    - allow-top-navigation-by-user-activation: Allow top navigation with user gesture
+    - allow-top-navigation-to-custom-protocols: Allow top navigation to custom protocols
+
+    Examples:
+    - "" (empty = maximum restrictions)
+    - "allow-scripts"
+    - "allow-same-origin allow-scripts"
+    - "allow-forms allow-popups allow-scripts"
+
+    Tokens are case-sensitive and must match exactly. Duplicate tokens are
+    allowed but redundant. An empty value means maximum sandbox restrictions. *)
+module Sandbox : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_scope.ml

···
+(** Table header scope attribute validation based on HTML5 spec *)
+
+(** Valid scope values *)
+let valid_scopes = [ "row"; "col"; "rowgroup"; "colgroup" ]
+
+module Scope = struct
+  let name = "scope"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_scopes then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid scope value. Expected one of: %s."
+           s
+           (String.concat ", " valid_scopes))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Scope : Datatype.S) ]

lib/html5_checker/datatype/dt_scope.mli

···
+(** Table header scope attribute datatype validator.
+
+    This module provides a validator for the scope attribute used on
+    th elements, as defined by the HTML5 specification. *)
+
+(** Table header scope attribute validator.
+
+    Validates th scope attribute values which can be:
+    - row - Header cell applies to some of the subsequent cells in the same row(s)
+    - col - Header cell applies to some of the subsequent cells in the same column(s)
+    - rowgroup - Header cell applies to all remaining cells in the row group
+    - colgroup - Header cell applies to all remaining cells in the column group
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "row"
+    - "col"
+    - "rowgroup"
+    - "colgroup" *)
+module Scope : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_shape.ml

···
+(** Shape attribute validation for HTML5 *)
+
+module Shape = struct
+  let name = "shape"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "default" | "rect" | "circle" | "poly" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid shape. Expected 'default', 'rect', \
+              'circle', or 'poly'."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Shape : Datatype.S) ]

lib/html5_checker/datatype/dt_shape.mli

···
+(** Shape attribute datatype validator for HTML5.
+
+    This module provides a validator for the shape attribute used on area
+    elements within image maps, as defined by the HTML5 specification. *)
+
+(** Shape attribute validator.
+
+    Validates shape attribute values which can be:
+    - "default" - entire region
+    - "rect" - rectangular region
+    - "circle" - circular region
+    - "poly" - polygonal region
+
+    Values are case-insensitive.
+
+    Examples:
+    - "rect"
+    - "circle"
+    - "poly"
+    - "default" *)
+module Shape : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_spellcheck.ml

···
+(** Spellcheck attribute validation for HTML5 *)
+
+module Spellcheck = struct
+  let name = "spellcheck"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "true" | "false" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid spellcheck value. Expected 'true', \
+              'false', or empty string."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Spellcheck : Datatype.S) ]

lib/html5_checker/datatype/dt_spellcheck.mli

···
+(** Spellcheck attribute datatype validator for HTML5.
+
+    This module provides a validator for the spellcheck attribute, as defined by
+    the HTML5 specification. *)
+
+(** Spellcheck attribute validator.
+
+    Validates spellcheck attribute values which can be:
+    - "true" - spelling and grammar checking is enabled
+    - "false" - spelling and grammar checking is disabled
+    - "" (empty string) - default behavior (typically inherits from parent)
+
+    Values are case-insensitive.
+
+    Examples:
+    - "true"
+    - "false"
+    - "" *)
+module Spellcheck : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_srcset.ml

···
+(** Image source set and sizes attribute validation *)
+
+(** Split string on commas, preserving parentheses groups *)
+let split_on_commas s =
+  let len = String.length s in
+  let rec find_splits paren_depth start i acc =
+    if i >= len then
+      if start < len then List.rev (String.sub s start (len - start) :: acc)
+      else List.rev acc
+    else
+      match s.[i] with
+      | '(' -> find_splits (paren_depth + 1) start (i + 1) acc
+      | ')' -> find_splits (max 0 (paren_depth - 1)) start (i + 1) acc
+      | ',' when paren_depth = 0 ->
+          let part = String.sub s start (i - start) in
+          find_splits 0 (i + 1) (i + 1) (part :: acc)
+      | _ -> find_splits paren_depth start (i + 1) acc
+  in
+  find_splits 0 0 0 []
+
+(** Parse a descriptor (width or pixel density) *)
+let parse_descriptor s =
+  let trimmed = Datatype.trim_html_spaces s in
+  let len = String.length trimmed in
+  if len < 2 then None
+  else
+    let suffix = trimmed.[len - 1] in
+    let num_part = String.sub trimmed 0 (len - 1) in
+    match suffix with
+    | 'w' ->
+        (try
+           let n = int_of_string num_part in
+           if n > 0 then Some (`Width n) else None
+         with _ -> None)
+    | 'x' ->
+        (try
+           let f = float_of_string num_part in
+           if f > 0.0 then Some (`Density f) else None
+         with _ -> None)
+    | _ -> None
+
+(** Validate a single image candidate *)
+let validate_image_candidate s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Image candidate must not be empty"
+  else
+    (* Split on whitespace to get URL and optional descriptor *)
+    let parts = String.split_on_char ' ' trimmed in
+    let parts = List.filter (fun p -> Datatype.trim_html_spaces p <> "") parts in
+    match parts with
+    | [] -> Error "Image candidate must not be empty"
+    | [ _url ] -> Ok None (* Just URL, no descriptor *)
+    | [ _url; desc ] -> (
+        match parse_descriptor desc with
+        | Some d -> Ok (Some d)
+        | None ->
+            Error
+              (Printf.sprintf
+                 "Invalid descriptor '%s'. Must be a positive integer followed \
+                  by 'w' or a positive number followed by 'x'"
+                 desc))
+    | _ ->
+        Error
+          "Image candidate must be a URL optionally followed by one descriptor"
+
+(** Validate srcset value *)
+let validate_srcset s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Srcset must not be empty" else
+  let candidates = split_on_commas trimmed in
+  let candidates = List.filter (fun c -> Datatype.trim_html_spaces c <> "") candidates in
+  if candidates = [] then Error "Srcset must contain at least one image candidate"
+  else
+    (* Validate each candidate and check for descriptor type consistency *)
+    let rec check_candidates has_width has_density = function
+      | [] -> Ok ()
+      | cand :: rest -> (
+          match validate_image_candidate cand with
+          | Error e -> Error e
+          | Ok None -> check_candidates has_width has_density rest
+          | Ok (Some (`Width _)) ->
+              if has_density then
+                Error
+                  "Cannot mix width descriptors (w) and pixel density \
+                   descriptors (x) in the same srcset"
+              else check_candidates true has_density rest
+          | Ok (Some (`Density _)) ->
+              if has_width then
+                Error
+                  "Cannot mix width descriptors (w) and pixel density \
+                   descriptors (x) in the same srcset"
+              else check_candidates has_width true rest)
+    in
+    check_candidates false false candidates
+
+module Srcset = struct
+  let name = "srcset"
+  let validate = validate_srcset
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Validate sizes attribute *)
+let validate_sizes s =
+  let trimmed = Datatype.trim_html_spaces s in
+  if trimmed = "" then Error "Sizes attribute must not be empty"
+  else
+    (* Split on commas *)
+    let entries = split_on_commas trimmed in
+    let entries = List.filter (fun e -> Datatype.trim_html_spaces e <> "") entries in
+    if entries = [] then Error "Sizes attribute must contain at least one entry"
+    else
+      (* Each entry except the last should have a media condition
+         The last entry is just a size value
+         We do basic validation here *)
+      let rec check_entries = function
+        | [] -> Ok ()
+        | [ _last ] ->
+            (* Last entry - just a size value, accept anything non-empty *)
+            Ok ()
+        | entry :: rest ->
+            let entry_trimmed = Datatype.trim_html_spaces entry in
+            (* Check if it looks like it has a media condition (starts with '(') *)
+            if String.length entry_trimmed = 0 then
+              Error "Size entry must not be empty"
+            else if entry_trimmed.[0] <> '(' then
+              Error
+                (Printf.sprintf
+                   "Size entry '%s' should start with a media condition in \
+                    parentheses"
+                   entry_trimmed)
+            else check_entries rest
+      in
+      check_entries entries
+
+module Sizes = struct
+  let name = "sizes"
+  let validate = validate_sizes
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [ (module Srcset : Datatype.S); (module Sizes : Datatype.S) ]

lib/html5_checker/datatype/dt_srcset.mli

···
+(** Image source set and sizes attribute validators.
+
+    This module provides validators for srcset and sizes attributes used on
+    img and source elements, as defined by the HTML5 specification. *)
+
+(** Srcset attribute validator.
+
+    Validates srcset attribute values which contain comma-separated image
+    candidates. Each image candidate consists of:
+    - A URL
+    - Optional whitespace followed by a width descriptor (e.g., "100w") or
+      pixel density descriptor (e.g., "2x")
+
+    Examples:
+    - "image.jpg"
+    - "image.jpg 1x"
+    - "image-320.jpg 320w, image-640.jpg 640w"
+    - "image-1x.jpg 1x, image-2x.jpg 2x"
+
+    Width descriptors must be positive integers followed by 'w'.
+    Pixel density descriptors must be positive numbers followed by 'x'.
+    Cannot mix width and density descriptors in the same srcset. *)
+module Srcset : Datatype.S
+
+(** Sizes attribute validator.
+
+    Validates sizes attribute values which contain comma-separated source size
+    entries. Each entry (except the last) consists of:
+    - A media condition
+    - Whitespace
+    - A source size value (length or "auto")
+
+    The last entry is just a source size value (without media condition).
+
+    Examples:
+    - "100vw"
+    - "(max-width: 600px) 100vw, 50vw"
+    - "(min-width: 800px) 800px, 100vw"
+
+    This validator performs basic syntax checking. *)
+module Sizes : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_target.ml

···
+(** Browsing context and target attribute validation *)
+
+(** Valid special target keywords (case-insensitive) *)
+let special_keywords = [ "_blank"; "_self"; "_parent"; "_top" ]
+
+(** Validate a browsing context name *)
+let validate_browsing_context s =
+  if String.length s = 0 then Error "Browsing context name must not be empty"
+  else if s.[0] = '_' then
+    (* If starts with underscore, must be a special keyword *)
+    let lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem lower special_keywords then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "Browsing context name '%s' starts with underscore but is not one \
+            of the special keywords: %s"
+           s (String.concat ", " special_keywords))
+  else Ok ()
+
+module Browsing_context = struct
+  let name = "browsing-context"
+  let validate = validate_browsing_context
+  let is_valid s = Result.is_ok (validate s)
+end
+
+(** Validate a target attribute value
+    (For now, this is the same as browsing context validation) *)
+let validate_target s =
+  if String.length s = 0 then Error "Target attribute must not be empty"
+  else validate_browsing_context s
+
+module Target = struct
+  let name = "target"
+  let validate = validate_target
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [
+    (module Target : Datatype.S); (module Browsing_context : Datatype.S);
+  ]

lib/html5_checker/datatype/dt_target.mli

···
+(** Browsing context and target attribute validators.
+
+    This module provides validators for browsing context names and target
+    attributes used on a, area, base, and form elements, as defined by the
+    HTML5 specification. *)
+
+(** Target attribute validator.
+
+    Validates target attribute values which specify where to display linked
+    content or form responses. Valid values include:
+
+    Special keywords (case-insensitive):
+    - _blank: New window or tab
+    - _self: Same frame (default)
+    - _parent: Parent frame
+    - _top: Top-level window
+
+    Or a valid browsing context name:
+    - Non-empty string
+    - If starts with underscore, must be one of the special keywords above
+
+    Examples:
+    - "_blank"
+    - "_self"
+    - "myframe"
+    - "content-frame" *)
+module Target : Datatype.S
+
+(** Browsing context name validator.
+
+    Validates browsing context names used to identify frames and windows.
+    A valid browsing context name is:
+    - A non-empty string
+    - If it starts with an underscore (_), it must be one of the special
+      keywords: _blank, _self, _parent, or _top (case-insensitive)
+    - Otherwise, any non-empty string is valid
+
+    Examples:
+    - "myframe"
+    - "content"
+    - "navigation-frame"
+    - "_blank" (special keyword)
+
+    Invalid examples:
+    - "" (empty string)
+    - "_custom" (underscore prefix but not a special keyword) *)
+module Browsing_context : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_translate.ml

···
+(** Translate attribute validation for HTML5 *)
+
+module Translate = struct
+  let name = "translate"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    match s_lower with
+    | "" | "yes" | "no" -> Ok ()
+    | _ ->
+        Error
+          (Printf.sprintf
+             "The value '%s' is not a valid translate value. Expected 'yes', \
+              'no', or empty string."
+             s)
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Translate : Datatype.S) ]

lib/html5_checker/datatype/dt_translate.mli

···
+(** Translate attribute datatype validator for HTML5.
+
+    This module provides a validator for the translate attribute, as defined by
+    the HTML5 specification. *)
+
+(** Translate attribute validator.
+
+    Validates translate attribute values which can be:
+    - "yes" - the element should be translated
+    - "no" - the element should not be translated
+    - "" (empty string) - equivalent to "yes"
+
+    Values are case-insensitive.
+
+    Examples:
+    - "yes"
+    - "no"
+    - "" *)
+module Translate : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_url.ml

···
+(** URL and IRI datatype validators for HTML5. *)
+
+(** Check if a character is valid in a URL scheme name.
+    Scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) *)
+let is_scheme_char_initial = function 'a' .. 'z' | 'A' .. 'Z' -> true | _ -> false
+
+let is_scheme_char_subsequent = function
+  | 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '+' | '-' | '.' -> true
+  | _ -> false
+
+(** Split a URL into scheme and remainder.
+    Returns Some (scheme, rest) if a valid scheme is found, None otherwise.
+    Skips leading HTML whitespace before checking for scheme. *)
+let split_scheme s =
+  let len = String.length s in
+  (* Skip leading HTML whitespace *)
+  let rec skip_whitespace i =
+    if i >= len then len
+    else if Datatype.is_whitespace s.[i] then skip_whitespace (i + 1)
+    else i
+  in
+  let start = skip_whitespace 0 in
+  if start >= len then None
+  else if not (is_scheme_char_initial s.[start]) then None
+  else
+    (* Look for scheme *)
+    let rec find_colon i =
+      if i >= len then None
+      else
+        match s.[i] with
+        | ':' ->
+            let scheme =
+              String.sub s start (i - start) |> Datatype.string_to_ascii_lowercase
+            in
+            let rest = String.sub s (i + 1) (len - i - 1) in
+            Some (scheme, rest)
+        | c when is_scheme_char_subsequent c -> find_colon (i + 1)
+        | _ -> None
+    in
+    find_colon (start + 1)
+
+(** Check if a scheme is well-known (http, https, ftp, mailto, file) *)
+let is_well_known_scheme = function
+  | "http" | "https" | "ftp" | "mailto" | "file" -> true
+  | _ -> false
+
+module Url : Datatype.S = struct
+  let name = "URL"
+
+  let validate s =
+    let trimmed = Datatype.trim_html_spaces s in
+    if trimmed = "" then Error "Must be non-empty."
+    else
+      (* Basic validation - check for control characters *)
+      let len = String.length s in
+      let rec check_chars i =
+        if i >= len then Ok ()
+        else
+          match s.[i] with
+          | '\x00' .. '\x1F' | '\x7F' ->
+              Error "URLs must not contain control characters."
+          | _ -> check_chars (i + 1)
+      in
+      check_chars 0
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Url_potentially_empty : Datatype.S = struct
+  let name = "URL (potentially empty)"
+
+  let validate s =
+    let trimmed = Datatype.trim_html_spaces s in
+    if trimmed = "" then Ok ()
+    else
+      (* Use same validation as Url for non-empty values *)
+      Url.validate s
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Url_absolute : Datatype.S = struct
+  let name = "absolute URL"
+
+  let validate s =
+    let trimmed = Datatype.trim_html_spaces s in
+    if trimmed = "" then Error "Must be non-empty."
+    else
+      match split_scheme s with
+      | None ->
+          Error (Printf.sprintf "The string \"%s\" is not an absolute URL." s)
+      | Some (scheme, _rest) ->
+          if is_well_known_scheme scheme || String.length scheme > 0 then
+            (* For well-known schemes, we could do more validation,
+               but for now we just check that it has a scheme *)
+            Ok ()
+          else Error "The string is not an absolute URL."
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Iri : Datatype.S = struct
+  let name = "absolute URL"
+
+  (* IRI validation is the same as absolute URL validation *)
+  let validate = Url_absolute.validate
+  let is_valid s = Result.is_ok (validate s)
+end
+
+module Iri_ref : Datatype.S = struct
+  let name = "URL"
+
+  (* IRI reference validation is the same as URL validation *)
+  let validate = Url.validate
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes =
+  [ (module Url : Datatype.S)
+  ; (module Url_potentially_empty : Datatype.S)
+  ; (module Url_absolute : Datatype.S)
+  ; (module Iri : Datatype.S)
+  ; (module Iri_ref : Datatype.S)
+  ]

lib/html5_checker/datatype/dt_url.mli

···
+(** URL and IRI datatype validators for HTML5.
+
+    This module provides validators for URLs and Internationalized Resource
+    Identifiers (IRIs) based on the Nu HTML Checker's implementation.
+
+    The validators perform basic structural validation. Full URL parsing and
+    validation according to WHATWG URL spec would require a complete URL parser. *)
+
+(** URL validator (IriRef in Nu validator).
+
+    Validates URL references which can be either absolute or relative URLs.
+    Basic validation ensures:
+    - Non-empty after trimming HTML whitespace
+    - No control characters
+    - Basic structural correctness
+
+    This corresponds to the general URL/IRI reference type. *)
+module Url : Datatype.S
+
+(** URL validator that allows empty values.
+
+    Same as Url but permits empty strings. This is used for optional URL
+    attributes. *)
+module Url_potentially_empty : Datatype.S
+
+(** Absolute URL validator (Iri in Nu validator).
+
+    Validates that a URL is absolute (has a scheme). An absolute URL must:
+    - Start with a valid scheme (e.g., http:, https:, ftp:, mailto:)
+    - Not be empty
+    - Follow URL structure rules
+
+    Scheme format: ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) *)
+module Url_absolute : Datatype.S
+
+(** IRI (Internationalized Resource Identifier) validator.
+
+    Alias for Url_absolute. IRIs are the internationalized version of URIs,
+    allowing Unicode characters. *)
+module Iri : Datatype.S
+
+(** IRI reference validator.
+
+    Alias for Url. IRI references can be relative or absolute. *)
+module Iri_ref : Datatype.S
+
+(** List of all URL/IRI-related datatypes for registration. *)
+val datatypes : Datatype.t list

lib/html5_checker/datatype/dt_wrap.ml

···
+(** Textarea wrap attribute validation based on HTML5 spec *)
+
+(** Valid wrap values *)
+let valid_wraps = [ "soft"; "hard" ]
+
+module Wrap = struct
+  let name = "wrap"
+
+  let validate s =
+    let s_lower = Datatype.string_to_ascii_lowercase s in
+    if List.mem s_lower valid_wraps then Ok ()
+    else
+      Error
+        (Printf.sprintf
+           "The value '%s' is not a valid wrap value. Expected one of: %s."
+           s
+           (String.concat ", " valid_wraps))
+
+  let is_valid s = Result.is_ok (validate s)
+end
+
+let datatypes = [ (module Wrap : Datatype.S) ]

lib/html5_checker/datatype/dt_wrap.mli

···
+(** Textarea wrap attribute datatype validator.
+
+    This module provides a validator for the wrap attribute used on
+    textarea elements, as defined by the HTML5 specification. *)
+
+(** Textarea wrap attribute validator.
+
+    Validates textarea wrap attribute values which can be:
+    - soft - Soft wrapping (line breaks not submitted, default)
+    - hard - Hard wrapping (line breaks are submitted)
+
+    Values are matched case-insensitively according to HTML5 spec.
+
+    Examples:
+    - "soft"
+    - "hard" *)
+module Wrap : Datatype.S
+
+(** List of all datatypes defined in this module *)
+val datatypes : Datatype.t list

lib/html5_checker/dom_walker.ml

···
+(** DOM tree traversal for HTML5 conformance checking. *)
+
+(** Package a checker with its state for traversal. *)
+type checker_state = {
+  start_element :
+    name:string ->
+    namespace:string option ->
+    attrs:(string * string) list ->
+    Message_collector.t ->
+    unit;
+  end_element :
+    name:string -> namespace:string option -> Message_collector.t -> unit;
+  characters : string -> Message_collector.t -> unit;
+  end_document : Message_collector.t -> unit;
+}
+
+(** Create a checker state package from a first-class module. *)
+let make_checker_state (module C : Checker.S) =
+  let state = C.create () in
+  {
+    start_element = (fun ~name ~namespace ~attrs collector ->
+      C.start_element state ~name ~namespace ~attrs collector);
+    end_element = (fun ~name ~namespace collector ->
+      C.end_element state ~name ~namespace collector);
+    characters = (fun text collector ->
+      C.characters state text collector);
+    end_document = (fun collector ->
+      C.end_document state collector);
+  }
+
+(** Walk a DOM node with a single checker state. *)
+let rec walk_node_single cs collector node =
+  let open Html5rw.Dom in
+  match node.name with
+  | "#text" ->
+      (* Text node: emit characters event *)
+      cs.characters node.data collector
+  | "#comment" ->
+      (* Comment node: emit characters event with comment text *)
+      cs.characters node.data collector
+  | "#document" | "#document-fragment" ->
+      (* Document/fragment nodes: just traverse children *)
+      List.iter (walk_node_single cs collector) node.children
+  | "!doctype" ->
+      (* Doctype node: skip (no validation events for doctype) *)
+      ()
+  | _ ->
+      (* Element node: emit start, traverse children, emit end *)
+      cs.start_element ~name:node.name ~namespace:node.namespace ~attrs:node.attrs collector;
+      List.iter (walk_node_single cs collector) node.children;
+      cs.end_element ~name:node.name ~namespace:node.namespace collector
+
+let walk checker collector node =
+  let cs = make_checker_state checker in
+  walk_node_single cs collector node;
+  cs.end_document collector
+
+(** Walk a DOM node with multiple checker states. *)
+let rec walk_node_all css collector node =
+  let open Html5rw.Dom in
+  match node.name with
+  | "#text" ->
+      (* Text node: emit characters event to all checkers *)
+      List.iter (fun cs -> cs.characters node.data collector) css
+  | "#comment" ->
+      (* Comment node: emit characters event with comment text to all checkers *)
+      List.iter (fun cs -> cs.characters node.data collector) css
+  | "#document" | "#document-fragment" ->
+      (* Document/fragment nodes: just traverse children *)
+      List.iter (walk_node_all css collector) node.children
+  | "!doctype" ->
+      (* Doctype node: skip *)
+      ()
+  | _ ->
+      (* Element node: emit start to all checkers, traverse children, emit end to all *)
+      List.iter (fun cs ->
+        cs.start_element ~name:node.name ~namespace:node.namespace ~attrs:node.attrs collector
+      ) css;
+      List.iter (walk_node_all css collector) node.children;
+      List.iter (fun cs ->
+        cs.end_element ~name:node.name ~namespace:node.namespace collector
+      ) css
+
+let walk_all checkers collector node =
+  (* Create checker state packages *)
+  let css = List.map make_checker_state checkers in
+  (* Traverse with all checkers *)
+  walk_node_all css collector node;
+  (* Call end_document on all checkers *)
+  List.iter (fun cs -> cs.end_document collector) css
+
+let walk_registry registry collector node =
+  let checkers = Checker_registry.all registry in
+  walk_all checkers collector node

lib/html5_checker/dom_walker.mli

···
+(** DOM tree traversal for HTML5 conformance checking.
+
+    This module provides functions to traverse DOM trees and apply checkers
+    to validate HTML5 documents. It implements a depth-first, in-order
+    traversal that visits every node in the tree and notifies checkers
+    of traversal events.
+
+    {2 Traversal Model}
+
+    The walker follows a SAX-like event model, emitting events as it
+    encounters different node types during traversal:
+
+    {v
+    Document
+    └── html (start_element "html")
+        ├── head (start_element "head")
+        │   └── title (start_element "title")
+        │       ├── #text "Page Title" (characters)
+        │       └── (end_element "title")
+        └── body (start_element "body")
+            └── p (start_element "p")
+                ├── #text "Hello " (characters)
+                ├── b (start_element "b")
+                │   ├── #text "world" (characters)
+                │   └── (end_element "b")
+                ├── #text "!" (characters)
+                └── (end_element "p")
+    end_document
+    v}
+
+    {2 Event Sequence}
+
+    For each element node:
+    1. {!Checker.S.start_element} is called when entering the element
+    2. Children are recursively traversed
+    3. {!Checker.S.end_element} is called when exiting the element
+
+    For text and comment nodes:
+    - {!Checker.S.characters} is called with the text content
+
+    After the entire tree is traversed:
+    - {!Checker.S.end_document} is called on all checkers
+
+    {2 Checker Coordination}
+
+    When multiple checkers are used:
+    - All checkers receive the same event sequence
+    - Events are delivered to checkers in the order they appear in the list
+    - Each checker maintains independent state
+    - Messages from all checkers are collected together
+
+    This allows composing orthogonal validation rules without interference.
+
+    {2 Usage Examples}
+
+    {b Single checker:}
+    {[
+      let checker = Checker.noop () in
+      let collector = Message_collector.create () in
+      walk checker collector dom;
+      let messages = Message_collector.messages collector in
+      List.iter Message.pp messages
+    ]}
+
+    {b Multiple checkers:}
+    {[
+      let checkers = [checker1; checker2; checker3] in
+      let collector = Message_collector.create () in
+      walk_all checkers collector dom;
+      (* Analyze messages from all checkers *)
+    ]}
+
+    {b Registry of checkers:}
+    {[
+      let registry = Checker_registry.default () in
+      let collector = Message_collector.create () in
+      walk_registry registry collector dom;
+      (* All registered checkers have validated the DOM *)
+    ]} *)
+
+(** {1 Single Checker Traversal} *)
+
+val walk : Checker.t -> Message_collector.t -> Html5rw.Dom.node -> unit
+(** [walk checker collector node] traverses a DOM tree with a single checker.
+
+    @param checker The checker to apply during traversal
+    @param collector The message collector for validation messages
+    @param node The root node to start traversal from
+
+    The traversal is depth-first and in-order: for each element, the
+    checker receives a {!Checker.S.start_element} event, then children
+    are recursively traversed, then an {!Checker.S.end_element} event
+    is emitted.
+
+    After the entire tree is traversed, {!Checker.S.end_document} is
+    called to allow the checker to emit any final validation messages.
+
+    {b Example:}
+    {[
+      (* Validate a parsed HTML document *)
+      let checker = Checker.noop () in
+      let collector = Message_collector.create () in
+      walk checker collector document_node;
+
+      (* Check for errors *)
+      let messages = Message_collector.messages collector in
+      let errors = List.filter
+        (fun msg -> msg.Message.severity = Message.Error)
+        messages in
+      if errors <> [] then
+        Printf.printf "Found %d errors\n" (List.length errors)
+    ]}
+
+    {b Notes:}
+    - Only element nodes trigger start/end events
+    - Text and comment nodes trigger character events
+    - Document and doctype nodes are silently skipped
+    - The traversal follows document order (parent before children,
+      earlier siblings before later ones) *)
+
+(** {1 Multiple Checker Traversal} *)
+
+val walk_all :
+  Checker.t list -> Message_collector.t -> Html5rw.Dom.node -> unit
+(** [walk_all checkers collector node] traverses a DOM tree with multiple
+    checkers.
+
+    @param checkers List of checkers to apply during traversal
+    @param collector The message collector for validation messages
+    @param node The root node to start traversal from
+
+    This performs a single tree traversal, delivering each event to all
+    checkers in sequence. This is more efficient than calling {!walk}
+    multiple times.
+
+    All checkers receive events in the order they appear in the list.
+    Each checker maintains independent state, so validation rules can
+    be composed without interference.
+
+    {b Example:}
+    {[
+      (* Run multiple validation passes in one traversal *)
+      let structure_checker = (module StructureChecker : Checker.S) in
+      let attribute_checker = (module AttributeChecker : Checker.S) in
+      let obsolete_checker = (module ObsoleteChecker : Checker.S) in
+
+      let checkers = [structure_checker; attribute_checker; obsolete_checker] in
+      let collector = Message_collector.create () in
+
+      walk_all checkers collector document_node;
+
+      (* All three checkers have validated the document *)
+      let messages = Message_collector.messages collector in
+      Message_format.print_messages messages
+    ]}
+
+    {b Empty list behavior:}
+    If the checkers list is empty, the tree is traversed but no validation
+    is performed. This is equivalent to calling [walk (Checker.noop ()) ...]. *)
+
+(** {1 Registry-Based Traversal} *)
+
+val walk_registry :
+  Checker_registry.t -> Message_collector.t -> Html5rw.Dom.node -> unit
+(** [walk_registry registry collector node] traverses a DOM tree with all
+    checkers from a registry.
+
+    @param registry The registry containing checkers to apply
+    @param collector The message collector for validation messages
+    @param node The root node to start traversal from
+
+    This is equivalent to:
+    {[
+      let checkers = Checker_registry.all registry in
+      walk_all checkers collector node
+    ]}
+
+    Use this when you want to run a pre-configured set of checkers
+    without manually extracting them from the registry.
+
+    {b Example:}
+    {[
+      (* Set up registry with desired checkers *)
+      let registry = Checker_registry.default () in
+      Checker_registry.register registry "custom" my_checker;
+
+      (* Validate multiple documents with same checker set *)
+      List.iter (fun doc ->
+        let collector = Message_collector.create () in
+        walk_registry registry collector doc;
+        report_results collector
+      ) documents
+    ]}
+
+    {b Empty registry behavior:}
+    If the registry is empty, the tree is traversed but no validation
+    is performed. *)

lib/html5_checker/dune

···
+(include_subdirs unqualified)
+
+(library
+ (name html5_checker)
+ (public_name html5rw.checker)
+ (libraries html5rw jsont jsont.bytesrw astring str)
+)

lib/html5_checker/html5_checker.ml

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+module Message = Message
+module Message_collector = Message_collector
+module Message_format = Message_format
+module Parse_error_bridge = Parse_error_bridge
+module Content_category = Content_category
+module Content_model = Content_model
+module Attr_spec = Attr_spec
+module Element_spec = Element_spec
+
+type t = {
+  doc : Html5rw.t;
+  msgs : Message.t list;
+  system_id : string option;
+}
+
+let check ?(collect_parse_errors = true) ?system_id reader =
+  let doc = Html5rw.parse ~collect_errors:collect_parse_errors reader in
+  let collector = Message_collector.create () in
+
+  (* Add parse errors if collected *)
+  if collect_parse_errors then begin
+    let parse_errors = Parse_error_bridge.collect_parse_errors ?system_id doc in
+    List.iter (Message_collector.add collector) parse_errors
+  end;
+
+  (* TODO: Run checkers via dom_walker when available *)
+  (* Dom_walker.walk_registry registry (Html5rw.root doc) collector; *)
+
+  { doc; msgs = Message_collector.messages collector; system_id }
+
+let check_dom ?(collect_parse_errors = true) ?system_id doc =
+  let collector = Message_collector.create () in
+
+  (* Add parse errors if requested *)
+  if collect_parse_errors then begin
+    let parse_errors = Parse_error_bridge.collect_parse_errors ?system_id doc in
+    List.iter (Message_collector.add collector) parse_errors
+  end;
+
+  (* TODO: Run checkers via dom_walker when available *)
+  (* Dom_walker.walk_registry registry (Html5rw.root doc) collector; *)
+
+  { doc; msgs = Message_collector.messages collector; system_id }
+
+let messages t = t.msgs
+
+let errors t =
+  List.filter
+    (fun msg -> msg.Message.severity = Message.Error)
+    t.msgs
+
+let warnings t =
+  List.filter
+    (fun msg -> msg.Message.severity = Message.Warning)
+    t.msgs
+
+let has_errors t =
+  List.exists
+    (fun msg -> msg.Message.severity = Message.Error)
+    t.msgs
+
+let document t = t.doc
+
+let system_id t = t.system_id
+
+let format_text t =
+  Message_format.format_text ?system_id:t.system_id t.msgs
+
+let format_json t =
+  Message_format.format_json ?system_id:t.system_id t.msgs
+
+let format_gnu t =
+  Message_format.format_gnu ?system_id:t.system_id t.msgs

lib/html5_checker/html5_checker.mli

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+(** HTML5 conformance checker.
+
+    This module provides HTML5 validation and conformance checking,
+    combining parse error detection with structural validation rules. *)
+
+(** {1 Re-exported modules} *)
+
+(** Validation message types and constructors. *)
+module Message = Message
+
+(** Message collection utilities. *)
+module Message_collector = Message_collector
+
+(** Message output formatters. *)
+module Message_format = Message_format
+
+(** Parse error bridge. *)
+module Parse_error_bridge = Parse_error_bridge
+
+(** {2 Content Model Framework} *)
+
+(** HTML5 content categories. *)
+module Content_category = Content_category
+
+(** HTML5 element content models. *)
+module Content_model = Content_model
+
+(** HTML5 attribute specifications. *)
+module Attr_spec = Attr_spec
+
+(** HTML5 element specifications. *)
+module Element_spec = Element_spec
+
+(** {1 Core Types} *)
+
+(** Result of checking an HTML document. *)
+type t
+
+(** {1 Checking Functions} *)
+
+(** Parse and validate HTML from a reader.
+
+    This function parses the HTML input and optionally collects parse errors.
+    Future versions will also run conformance checkers on the resulting DOM.
+
+    @param collect_parse_errors If true, collect and include parse errors. Default: true.
+    @param system_id Optional file path or URL for error reporting.
+    @param reader Bytesrw reader containing HTML input. *)
+val check :
+  ?collect_parse_errors:bool ->
+  ?system_id:string ->
+  Bytesrw.Bytes.Reader.t ->
+  t
+
+(** Validate an already-parsed HTML document.
+
+    This function takes an existing Html5rw.t parse result and validates it.
+
+    @param collect_parse_errors If true, collect and include parse errors from the result. Default: true.
+    @param system_id Optional file path or URL for error reporting.
+    @param result Already-parsed HTML document. *)
+val check_dom :
+  ?collect_parse_errors:bool ->
+  ?system_id:string ->
+  Html5rw.t ->
+  t
+
+(** {1 Result Accessors} *)
+
+(** Get all validation messages. *)
+val messages : t -> Message.t list
+
+(** Get only error messages. *)
+val errors : t -> Message.t list
+
+(** Get only warning messages. *)
+val warnings : t -> Message.t list
+
+(** Check if there are any errors. *)
+val has_errors : t -> bool
+
+(** Get the underlying parsed document. *)
+val document : t -> Html5rw.t
+
+(** Get the system identifier if set. *)
+val system_id : t -> string option
+
+(** {1 Formatting} *)
+
+(** Format messages as human-readable text. *)
+val format_text : t -> string
+
+(** Format messages as JSON. *)
+val format_json : t -> string
+
+(** Format messages in GNU style. *)
+val format_gnu : t -> string

lib/html5_checker/message.ml

···
+type severity = Error | Warning | Info
+
+type location = {
+  line : int;
+  column : int;
+  end_line : int option;
+  end_column : int option;
+  system_id : string option;
+}
+
+type t = {
+  severity : severity;
+  message : string;
+  code : string option;
+  location : location option;
+  element : string option;
+  attribute : string option;
+  extract : string option;
+}
+
+let make ~severity ~message ?code ?location ?element ?attribute ?extract () =
+  { severity; message; code; location; element; attribute; extract }
+
+let error ~message ?code ?location ?element ?attribute ?extract () =
+  make ~severity:Error ~message ?code ?location ?element ?attribute ?extract ()
+
+let warning ~message ?code ?location ?element ?attribute ?extract () =
+  make ~severity:Warning ~message ?code ?location ?element ?attribute ?extract
+    ()
+
+let info ~message ?code ?location ?element ?attribute ?extract () =
+  make ~severity:Info ~message ?code ?location ?element ?attribute ?extract ()
+
+let make_location ~line ~column ?end_line ?end_column ?system_id () =
+  { line; column; end_line; end_column; system_id }
+
+let severity_to_string = function
+  | Error -> "error"
+  | Warning -> "warning"
+  | Info -> "info"
+
+let pp_severity fmt severity =
+  Format.pp_print_string fmt (severity_to_string severity)
+
+let pp_location fmt loc =
+  match loc.system_id with
+  | Some sid -> Format.fprintf fmt "%s:" sid
+  | None -> ();
+  Format.fprintf fmt "%d:%d" loc.line loc.column;
+  match (loc.end_line, loc.end_column) with
+  | Some el, Some ec when el = loc.line && ec > loc.column ->
+      Format.fprintf fmt "-%d" ec
+  | Some el, Some ec when el > loc.line ->
+      Format.fprintf fmt "-%d:%d" el ec
+  | _ -> ()
+
+let pp fmt msg =
+  (match msg.location with
+  | Some loc ->
+      pp_location fmt loc;
+      Format.fprintf fmt ": "
+  | None -> ());
+  pp_severity fmt msg.severity;
+  (match msg.code with
+  | Some code -> Format.fprintf fmt " [%s]" code
+  | None -> ());
+  Format.fprintf fmt ": %s" msg.message;
+  (match msg.element with
+  | Some elem -> Format.fprintf fmt " (element: %s)" elem
+  | None -> ());
+  match msg.attribute with
+  | Some attr -> Format.fprintf fmt " (attribute: %s)" attr
+  | None -> ()
+
+let to_string msg =
+  let buf = Buffer.create 256 in
+  let fmt = Format.formatter_of_buffer buf in
+  pp fmt msg;
+  Format.pp_print_flush fmt ();
+  Buffer.contents buf

lib/html5_checker/message.mli

···
+(** HTML5 validation messages.
+
+    This module provides types for validation messages including errors,
+    warnings, and informational messages with source location tracking. *)
+
+(** Message severity levels. *)
+type severity =
+  | Error  (** Conformance error - document is invalid *)
+  | Warning  (** Conformance warning - likely problematic *)
+  | Info  (** Informational - suggestions for improvement *)
+
+(** Source location information. *)
+type location = {
+  line : int;  (** 1-indexed line number *)
+  column : int;  (** 1-indexed column number *)
+  end_line : int option;  (** Optional end line for ranges *)
+  end_column : int option;  (** Optional end column *)
+  system_id : string option;  (** File path or URL *)
+}
+
+(** A validation message. *)
+type t = {
+  severity : severity;
+  message : string;  (** Human-readable description *)
+  code : string option;  (** Machine-readable error code *)
+  location : location option;
+  element : string option;  (** Element name if relevant *)
+  attribute : string option;  (** Attribute name if relevant *)
+  extract : string option;  (** Source excerpt *)
+}
+
+(** {1 Constructors} *)
+
+(** Create a validation message with specified severity. *)
+val make :
+  severity:severity ->
+  message:string ->
+  ?code:string ->
+  ?location:location ->
+  ?element:string ->
+  ?attribute:string ->
+  ?extract:string ->
+  unit ->
+  t
+
+(** Create an error message. *)
+val error :
+  message:string ->
+  ?code:string ->
+  ?location:location ->
+  ?element:string ->
+  ?attribute:string ->
+  ?extract:string ->
+  unit ->
+  t
+
+(** Create a warning message. *)
+val warning :
+  message:string ->
+  ?code:string ->
+  ?location:location ->
+  ?element:string ->
+  ?attribute:string ->
+  ?extract:string ->
+  unit ->
+  t
+
+(** Create an informational message. *)
+val info :
+  message:string ->
+  ?code:string ->
+  ?location:location ->
+  ?element:string ->
+  ?attribute:string ->
+  ?extract:string ->
+  unit ->
+  t
+
+(** Create a location record. *)
+val make_location :
+  line:int ->
+  column:int ->
+  ?end_line:int ->
+  ?end_column:int ->
+  ?system_id:string ->
+  unit ->
+  location
+
+(** {1 Formatting} *)
+
+(** Convert severity to string representation. *)
+val severity_to_string : severity -> string
+
+(** Pretty-print severity. *)
+val pp_severity : Format.formatter -> severity -> unit
+
+(** Pretty-print location. *)
+val pp_location : Format.formatter -> location -> unit
+
+(** Pretty-print a validation message. *)
+val pp : Format.formatter -> t -> unit
+
+(** Convert a validation message to a string. *)
+val to_string : t -> string

lib/html5_checker/message_collector.ml

···
+type t = { mutable messages : Message.t list }
+
+let create () = { messages = [] }
+
+let add t msg = t.messages <- msg :: t.messages
+
+let add_error t ~message ?code ?location ?element ?attribute ?extract () =
+  let msg =
+    Message.error ~message ?code ?location ?element ?attribute ?extract ()
+  in
+  add t msg
+
+let add_warning t ~message ?code ?location ?element ?attribute ?extract () =
+  let msg =
+    Message.warning ~message ?code ?location ?element ?attribute ?extract ()
+  in
+  add t msg
+
+let messages t = List.rev t.messages
+
+let errors t =
+  List.filter (fun msg -> msg.Message.severity = Message.Error) (messages t)
+
+let warnings t =
+  List.filter (fun msg -> msg.Message.severity = Message.Warning) (messages t)
+
+let has_errors t =
+  List.exists (fun msg -> msg.Message.severity = Message.Error) t.messages
+
+let count t = List.length t.messages
+
+let error_count t =
+  List.fold_left
+    (fun acc msg ->
+      if msg.Message.severity = Message.Error then acc + 1 else acc)
+    0 t.messages
+
+let clear t = t.messages <- []

lib/html5_checker/message_collector.mli

···
+(** Message collector for accumulating validation messages. *)
+
+(** The type of a message collector. *)
+type t
+
+(** {1 Creation} *)
+
+(** Create a new empty message collector. *)
+val create : unit -> t
+
+(** {1 Adding Messages} *)
+
+(** Add a message to the collector. *)
+val add : t -> Message.t -> unit
+
+(** Add an error message to the collector. *)
+val add_error :
+  t ->
+  message:string ->
+  ?code:string ->
+  ?location:Message.location ->
+  ?element:string ->
+  ?attribute:string ->
+  ?extract:string ->
+  unit ->
+  unit
+
+(** Add a warning message to the collector. *)
+val add_warning :
+  t ->
+  message:string ->
+  ?code:string ->
+  ?location:Message.location ->
+  ?element:string ->
+  ?attribute:string ->
+  ?extract:string ->
+  unit ->
+  unit
+
+(** {1 Retrieving Messages} *)
+
+(** Get all messages in the order they were added. *)
+val messages : t -> Message.t list
+
+(** Get only error messages. *)
+val errors : t -> Message.t list
+
+(** Get only warning messages. *)
+val warnings : t -> Message.t list
+
+(** {1 Status Queries} *)
+
+(** Check if the collector contains any error messages. *)
+val has_errors : t -> bool
+
+(** Get the total number of messages. *)
+val count : t -> int
+
+(** Get the number of error messages. *)
+val error_count : t -> int
+
+(** {1 Modification} *)
+
+(** Clear all messages from the collector. *)
+val clear : t -> unit

lib/html5_checker/message_format.ml

···
+let format_text ?system_id messages =
+  let buf = Buffer.create 1024 in
+  List.iter
+    (fun msg ->
+      let loc_str =
+        match msg.Message.location with
+        | Some loc -> (
+            let sid =
+              match loc.Message.system_id with
+              | Some s -> s
+              | None -> (
+                  match system_id with Some s -> s | None -> "input")
+            in
+            let col_info =
+              match (loc.end_line, loc.end_column) with
+              | Some el, Some ec when el = loc.line && ec > loc.column ->
+                  Printf.sprintf "%d.%d-%d" loc.line loc.column ec
+              | Some el, Some ec when el > loc.line ->
+                  Printf.sprintf "%d.%d-%d.%d" loc.line loc.column el ec
+              | _ -> Printf.sprintf "%d.%d" loc.line loc.column
+            in
+            Printf.sprintf "%s:%s" sid col_info)
+        | None -> (
+            match system_id with Some s -> s | None -> "input")
+      in
+      let severity_str = Message.severity_to_string msg.Message.severity in
+      let code_str =
+        match msg.Message.code with Some c -> " [" ^ c ^ "]" | None -> ""
+      in
+      let elem_str =
+        match msg.Message.element with
+        | Some e -> " (element: " ^ e ^ ")"
+        | None -> ""
+      in
+      let attr_str =
+        match msg.Message.attribute with
+        | Some a -> " (attribute: " ^ a ^ ")"
+        | None -> ""
+      in
+      Buffer.add_string buf
+        (Printf.sprintf "%s: %s%s: %s%s%s\n" loc_str severity_str code_str
+           msg.Message.message elem_str attr_str))
+    messages;
+  Buffer.contents buf
+
+let format_gnu ?system_id messages =
+  let buf = Buffer.create 1024 in
+  List.iter
+    (fun msg ->
+      let loc_str =
+        match msg.Message.location with
+        | Some loc -> (
+            let sid =
+              match loc.Message.system_id with
+              | Some s -> s
+              | None -> (
+                  match system_id with Some s -> s | None -> "input")
+            in
+            Printf.sprintf "%s:%d:%d" sid loc.line loc.column)
+        | None -> (
+            match system_id with Some s -> s ^ ":0:0" | None -> "input:0:0")
+      in
+      let severity_str = Message.severity_to_string msg.Message.severity in
+      let code_str =
+        match msg.Message.code with Some c -> " [" ^ c ^ "]" | None -> ""
+      in
+      Buffer.add_string buf
+        (Printf.sprintf "%s: %s%s: %s\n" loc_str severity_str code_str
+           msg.Message.message))
+    messages;
+  Buffer.contents buf
+
+let message_to_json ?system_id msg =
+  let open Jsont in
+  let severity = String (Message.severity_to_string msg.Message.severity, Meta.none) in
+  let message_text = String (msg.Message.message, Meta.none) in
+  let base = [ (("type", Meta.none), severity); (("message", Meta.none), message_text) ] in
+  let with_code =
+    match msg.Message.code with
+    | Some c -> (("subType", Meta.none), String (c, Meta.none)) :: base
+    | None -> base
+  in
+  let with_location =
+    match msg.Message.location with
+    | Some loc ->
+        let line = Number (float_of_int loc.Message.line, Meta.none) in
+        let column = Number (float_of_int loc.Message.column, Meta.none) in
+        let loc_fields =
+          [ (("firstLine", Meta.none), line); (("firstColumn", Meta.none), column) ]
+        in
+        let loc_fields =
+          match loc.Message.end_line with
+          | Some el ->
+              (("lastLine", Meta.none), Number (float_of_int el, Meta.none)) :: loc_fields
+          | None -> loc_fields
+        in
+        let loc_fields =
+          match loc.Message.end_column with
+          | Some ec ->
+              (("lastColumn", Meta.none), Number (float_of_int ec, Meta.none))
+              :: loc_fields
+          | None -> loc_fields
+        in
+        let url =
+          match loc.Message.system_id with
+          | Some s -> s
+          | None -> (
+              match system_id with Some s -> s | None -> "input")
+        in
+        (("url", Meta.none), String (url, Meta.none)) :: loc_fields @ with_code
+    | None ->
+        let url =
+          match system_id with Some s -> s | None -> "input"
+        in
+        (("url", Meta.none), String (url, Meta.none)) :: with_code
+  in
+  let with_extract =
+    match msg.Message.extract with
+    | Some e -> (("extract", Meta.none), String (e, Meta.none)) :: with_location
+    | None -> with_location
+  in
+  Object (with_extract, Meta.none)
+
+let format_json ?system_id messages =
+  let open Jsont in
+  let msg_array = Array (List.map (message_to_json ?system_id) messages, Meta.none) in
+  let obj = Object ([ (("messages", Meta.none), msg_array) ], Meta.none) in
+  match Jsont_bytesrw.encode_string ~format:Minify json obj with
+  | Ok s -> s
+  | Error e -> failwith ("JSON encoding error: " ^ e)

lib/html5_checker/message_format.mli

···
+(** Message output formatters.
+
+    This module provides various output formats for validation messages,
+    including text, JSON, and GNU-style formats for IDE integration. *)
+
+(** {1 Formatters} *)
+
+(** Format messages as human-readable text.
+
+    Output format: [file:line:col: severity: message]
+
+    @param system_id Optional default system identifier for messages without location. *)
+val format_text : ?system_id:string -> Message.t list -> string
+
+(** Format messages as JSON.
+
+    Produces output compatible with the Nu HTML Validator JSON format.
+
+    @param system_id Optional default system identifier for messages without location. *)
+val format_json : ?system_id:string -> Message.t list -> string
+
+(** Format messages in GNU style for IDE integration.
+
+    Output format follows GNU conventions for error messages, compatible
+    with most IDEs and editors.
+
+    @param system_id Optional default system identifier for messages without location. *)
+val format_gnu : ?system_id:string -> Message.t list -> string

lib/html5_checker/parse_error_bridge.ml

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+let of_parse_error ?system_id err =
+  let code = Html5rw.error_code err in
+  let line = Html5rw.error_line err in
+  let column = Html5rw.error_column err in
+  let location =
+    Message.make_location ~line ~column ?system_id ()
+  in
+  let code_str = Html5rw.Parse_error_code.to_string code in
+  Message.error
+    ~message:(Printf.sprintf "Parse error: %s" code_str)
+    ~code:code_str
+    ~location
+    ()
+
+let collect_parse_errors ?system_id result =
+  let errors = Html5rw.errors result in
+  List.map (of_parse_error ?system_id) errors

lib/html5_checker/parse_error_bridge.mli

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+(** Bridge between Html5rw parse errors and validation messages.
+
+    This module converts parse errors from the Html5rw parser into
+    standardized validation messages. *)
+
+(** Convert a parse error to a validation message.
+
+    Extracts error code, line, column, and creates a Message.t with
+    severity set to Error.
+
+    @param system_id Optional file path or URL to include in location *)
+val of_parse_error : ?system_id:string -> Html5rw.parse_error -> Message.t
+
+(** Collect all parse errors from a parse result.
+
+    Extracts all parse errors from the Html5rw.t result and converts
+    them to validation messages.
+
+    @param system_id Optional file path or URL to include in locations *)
+val collect_parse_errors : ?system_id:string -> Html5rw.t -> Message.t list

lib/html5_checker/semantic/form_checker.ml

···
+(** Form-related validation checker implementation. *)
+
+type state = {
+  mutable in_form : bool;
+  (** Track if we're currently inside a <form> element *)
+  mutable form_ids : string list;
+  (** Stack of form IDs we're currently nested in *)
+  mutable label_for_refs : string list;
+  (** Collect all label[for] references to validate later *)
+  mutable element_ids : string list;
+  (** Collect all element IDs to validate label references *)
+  mutable unlabeled_controls : (string * string option) list;
+      (** Controls that might need labels: (type, id) *)
+}
+
+let create () =
+  {
+    in_form = false;
+    form_ids = [];
+    label_for_refs = [];
+    element_ids = [];
+    unlabeled_controls = [];
+  }
+
+let reset state =
+  state.in_form <- false;
+  state.form_ids <- [];
+  state.label_for_refs <- [];
+  state.element_ids <- [];
+  state.unlabeled_controls <- []
+
+(** Check if an attribute list contains a specific attribute. *)
+let has_attr name attrs =
+  List.exists (fun (attr_name, _) -> String.equal attr_name name) attrs
+
+(** Get the value of an attribute if present. *)
+let get_attr name attrs =
+  List.find_map
+    (fun (attr_name, value) ->
+      if String.equal attr_name name then Some value else None)
+    attrs
+
+(** Check if an element is labelable. *)
+let _is_labelable_element name input_type =
+  match name with
+  | "button" | "meter" | "output" | "progress" | "select" | "textarea" -> true
+  | "input" -> (
+      match input_type with Some "hidden" -> false | _ -> true)
+  | _ -> false
+
+(** Valid autocomplete tokens for various input types. *)
+let valid_autocomplete_tokens =
+  [
+    "on";
+    "off";
+    "name";
+    "honorific-prefix";
+    "given-name";
+    "additional-name";
+    "family-name";
+    "honorific-suffix";
+    "nickname";
+    "email";
+    "username";
+    "new-password";
+    "current-password";
+    "one-time-code";
+    "organization-title";
+    "organization";
+    "street-address";
+    "address-line1";
+    "address-line2";
+    "address-line3";
+    "address-level4";
+    "address-level3";
+    "address-level2";
+    "address-level1";
+    "country";
+    "country-name";
+    "postal-code";
+    "cc-name";
+    "cc-given-name";
+    "cc-additional-name";
+    "cc-family-name";
+    "cc-number";
+    "cc-exp";
+    "cc-exp-month";
+    "cc-exp-year";
+    "cc-csc";
+    "cc-type";
+    "transaction-currency";
+    "transaction-amount";
+    "language";
+    "bday";
+    "bday-day";
+    "bday-month";
+    "bday-year";
+    "sex";
+    "tel";
+    "tel-country-code";
+    "tel-national";
+    "tel-area-code";
+    "tel-local";
+    "tel-extension";
+    "impp";
+    "url";
+    "photo";
+  ]
+
+let check_autocomplete_value value _input_type collector =
+  (* Parse autocomplete value - can be space-separated tokens *)
+  let tokens = String.split_on_char ' ' value |> List.map String.trim in
+  let tokens = List.filter (fun s -> String.length s > 0) tokens in
+
+  (* The last token should be a valid autocomplete token *)
+  match List.rev tokens with
+  | [] -> ()
+  | last_token :: _prefix_tokens ->
+      if not (List.mem last_token valid_autocomplete_tokens) then
+        Message_collector.add_warning collector
+          ~message:
+            (Printf.sprintf "Unknown autocomplete value: %s" last_token)
+          ~code:"invalid-autocomplete-value" ~element:"input"
+          ~attribute:"autocomplete" ()
+
+let check_input_element state attrs collector =
+  let input_type = get_attr "type" attrs in
+  let id = get_attr "id" attrs in
+
+  (* Track this input's ID if present *)
+  (match id with
+  | Some id_val -> state.element_ids <- id_val :: state.element_ids
+  | None -> ());
+
+  (* Check various input-specific rules *)
+  (match input_type with
+  | Some "radio" | Some "checkbox" ->
+      (* Radio and checkbox should have labels *)
+      state.unlabeled_controls <-
+        (Option.value input_type ~default:"text", id)
+        :: state.unlabeled_controls
+  | Some "submit" | Some "button" | Some "reset" ->
+      (* These don't need labels *)
+      ()
+  | _ -> ());
+
+  (* Check autocomplete attribute *)
+  (match get_attr "autocomplete" attrs with
+  | Some autocomplete_value ->
+      check_autocomplete_value autocomplete_value input_type collector
+  | None -> ());
+
+  (* Check for select multiple with size=1 *)
+  ()
+
+let check_select_element attrs collector =
+  let multiple = has_attr "multiple" attrs in
+  let size = get_attr "size" attrs in
+
+  match (multiple, size) with
+  | true, Some "1" ->
+      Message_collector.add_warning collector
+        ~message:"select element with multiple should not have size=\"1\""
+        ~code:"contradictory-attributes" ~element:"select" ~attribute:"size"
+        ()
+  | _ -> ()
+
+let check_button_element state attrs collector =
+  (* button[type=submit] should be in form or have form attribute *)
+  let button_type = get_attr "type" attrs in
+  let has_form_attr = has_attr "form" attrs in
+
+  match button_type with
+  | Some "submit" | None ->
+      (* Default type is submit *)
+      if (not state.in_form) && not has_form_attr then
+        Message_collector.add_warning collector
+          ~message:
+            "button element with type=\"submit\" should be inside a form or \
+             have form attribute"
+          ~code:"submit-button-outside-form" ~element:"button" ()
+  | _ -> ()
+
+let check_label_element state attrs _collector =
+  (* Collect label[for] references *)
+  match get_attr "for" attrs with
+  | Some for_id -> state.label_for_refs <- for_id :: state.label_for_refs
+  | None -> ()
+
+let start_element state ~name ~namespace:_ ~attrs collector =
+  (* Track element IDs *)
+  (match get_attr "id" attrs with
+  | Some id_val -> state.element_ids <- id_val :: state.element_ids
+  | None -> ());
+
+  match name with
+  | "form" ->
+      state.in_form <- true;
+      (match get_attr "id" attrs with
+      | Some id -> state.form_ids <- id :: state.form_ids
+      | None -> ())
+  | "input" -> check_input_element state attrs collector
+  | "select" -> check_select_element attrs collector
+  | "button" -> check_button_element state attrs collector
+  | "label" -> check_label_element state attrs collector
+  | _ -> ()
+
+let end_element state ~name ~namespace:_ _collector =
+  match name with
+  | "form" ->
+      state.in_form <- false;
+      (match state.form_ids with
+      | _ :: rest -> state.form_ids <- rest
+      | [] -> ())
+  | _ -> ()
+
+let characters _state _text _collector = ()
+
+let end_document state collector =
+  (* Validate label[for] references *)
+  List.iter
+    (fun for_id ->
+      if not (List.mem for_id state.element_ids) then
+        Message_collector.add_warning collector
+          ~message:
+            (Printf.sprintf
+               "label element references non-existent ID: %s" for_id)
+          ~code:"invalid-label-reference" ~element:"label" ~attribute:"for"
+          ())
+    state.label_for_refs;
+
+  (* Note: We can't reliably detect unlabeled controls without tracking
+     label parent-child relationships, which would require more complex
+     state tracking. For now, we just validate explicit label[for] references. *)
+  ()
+
+let checker = (module struct
+  type nonrec state = state
+
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/semantic/form_checker.mli

···
+(** Form-related validation checker.
+
+    Validates form control associations, label references, and form structure
+    according to HTML5 accessibility and semantic requirements. This checker
+    ensures that:
+
+    - Form controls have proper labels
+    - Label associations are valid
+    - Form attributes are correctly configured
+    - Form structure follows HTML5 constraints
+
+    {2 Validation Rules}
+
+    {b Label Associations}
+    - [label] with [for] attribute should reference a labelable element ID
+    - [input\[type=radio\]] should have an associated visible label
+    - [input\[type=checkbox\]] should have an associated visible label
+
+    {b Form Control Validation}
+    - [button\[type=submit\]] should be inside a [form] or have [form] attribute
+    - [input\[type=image\]] requires [alt] attribute (validated by required_attr_checker)
+    - [input\[type=hidden\]] should not have [required] attribute (validated by required_attr_checker)
+    - [input\[type=file\]] should not have [value] attribute (validated by required_attr_checker)
+
+    {b Autocomplete}
+    - [autocomplete] values should be appropriate for the [input] type
+    - Common autocomplete values include: [on], [off], [name], [email],
+      [username], [current-password], [new-password], [street-address], etc.
+
+    {b Select Elements}
+    - [select\[multiple\]] should not have [size="1"] (contradictory)
+    - [select] should contain at least one [option] or [optgroup]
+
+    {b Accessibility}
+    - Form controls should be reachable and operable via keyboard
+    - Radio buttons with the same [name] should form a logical group
+
+    {3 Labelable Elements}
+
+    The following elements can be associated with a [label]:
+    - [button]
+    - [input] (except [type=hidden])
+    - [meter]
+    - [output]
+    - [progress]
+    - [select]
+    - [textarea]
+
+    @see <https://html.spec.whatwg.org/multipage/forms.html> WHATWG HTML: Forms
+    @see <https://www.w3.org/WAI/WCAG21/Understanding/labels-or-instructions.html>
+         WCAG: Labels or Instructions *)
+
+include Checker.S
+
+val checker : Checker.t
+(** A first-class module instance of this checker.
+
+    {b Usage:}
+    {[
+      let checker = Form_checker.checker in
+      Checker_registry.register "form-validation" checker
+    ]} *)

lib/html5_checker/semantic/id_checker.ml

···
+(** ID uniqueness and reference checker.
+
+    This checker validates that:
+    - ID attributes are unique within the document
+    - ID references point to existing IDs
+    - ID values conform to HTML5 requirements *)
+
+(** Location information for ID occurrences. *)
+type id_location = {
+  element : string;
+  location : Message.location option;
+}
+
+(** Information about an ID reference. *)
+type id_reference = {
+  referring_element : string;
+  attribute : string;
+  referenced_id : string;
+  location : Message.location option;
+}
+
+(** Checker state tracking IDs and references. *)
+type state = {
+  ids : (string, id_location) Hashtbl.t;
+  mutable references : id_reference list;
+}
+
+let create () =
+  {
+    ids = Hashtbl.create 64;
+    references = [];
+  }
+
+let reset state =
+  Hashtbl.clear state.ids;
+  state.references <- []
+
+(** Check if a string contains whitespace. *)
+let contains_whitespace s =
+  String.contains s ' ' || String.contains s '\t' ||
+  String.contains s '\n' || String.contains s '\r'
+
+(** Extract ID from a usemap value (removes leading #). *)
+let extract_usemap_id value =
+  if String.length value > 0 && value.[0] = '#' then
+    Some (String.sub value 1 (String.length value - 1))
+  else
+    None
+
+(** Split whitespace-separated ID references. *)
+let split_ids value =
+  let rec split acc start i =
+    if i >= String.length value then
+      if i > start then
+        (String.sub value start (i - start)) :: acc
+      else
+        acc
+    else
+      match value.[i] with
+      | ' ' | '\t' | '\n' | '\r' ->
+          let acc' =
+            if i > start then
+              (String.sub value start (i - start)) :: acc
+            else
+              acc
+          in
+          split acc' (i + 1) (i + 1)
+      | _ ->
+          split acc start (i + 1)
+  in
+  List.rev (split [] 0 0)
+
+(** Attributes that reference a single ID. *)
+let single_id_ref_attrs = [
+  "for";         (* label *)
+  "form";        (* form-associated elements *)
+  "list";        (* input *)
+  "aria-activedescendant";
+]
+
+(** Attributes that reference multiple IDs (space-separated). *)
+let multi_id_ref_attrs = [
+  "headers";     (* td, th *)
+  "aria-labelledby";
+  "aria-describedby";
+  "aria-controls";
+  "aria-flowto";
+  "aria-owns";
+  "itemref";
+]
+
+(** Check and store an ID attribute. *)
+let check_id state ~element ~id ~location collector =
+  (* Check for empty ID *)
+  if String.length id = 0 then
+    Message_collector.add_error collector
+      ~message:"ID attribute must not be empty"
+      ~code:"empty-id"
+      ?location
+      ~element
+      ~attribute:"id"
+      ()
+  (* Check for whitespace in ID *)
+  else if contains_whitespace id then
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "ID attribute value '%s' must not contain whitespace" id)
+      ~code:"id-whitespace"
+      ?location
+      ~element
+      ~attribute:"id"
+      ()
+  (* Check for duplicate ID *)
+  else if Hashtbl.mem state.ids id then
+    let first_occurrence = Hashtbl.find state.ids id in
+    let first_loc_str = match first_occurrence.location with
+      | None -> ""
+      | Some loc -> Printf.sprintf " at line %d, column %d" loc.line loc.column
+    in
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf
+        "Duplicate ID '%s': first used on <%s>%s, now on <%s>"
+        id first_occurrence.element first_loc_str element)
+      ~code:"duplicate-id"
+      ?location
+      ~element
+      ~attribute:"id"
+      ()
+  else
+    (* Store the ID *)
+    Hashtbl.add state.ids id { element; location }
+
+(** Record a single ID reference. *)
+let add_reference state ~referring_element ~attribute ~referenced_id ~location =
+  if String.length referenced_id > 0 then
+    state.references <- {
+      referring_element;
+      attribute;
+      referenced_id;
+      location;
+    } :: state.references
+
+(** Process attributes to check IDs and collect references. *)
+let process_attrs state ~element ~attrs ~location collector =
+  List.iter (fun (name, value) ->
+    match name with
+    | "id" ->
+        check_id state ~element ~id:value ~location collector
+
+    | "usemap" ->
+        (* usemap references a map name, which is like an ID reference *)
+        begin match extract_usemap_id value with
+        | Some id ->
+            add_reference state ~referring_element:element
+              ~attribute:name ~referenced_id:id ~location
+        | None ->
+            if String.length value > 0 then
+              Message_collector.add_error collector
+                ~message:(Printf.sprintf
+                  "usemap attribute value '%s' must start with '#'" value)
+                ~code:"invalid-usemap"
+                ?location
+                ~element
+                ~attribute:name
+                ()
+        end
+
+    | attr when List.mem attr single_id_ref_attrs ->
+        add_reference state ~referring_element:element
+          ~attribute:attr ~referenced_id:value ~location
+
+    | attr when List.mem attr multi_id_ref_attrs ->
+        (* Split space-separated IDs and add each as a reference *)
+        let ids = split_ids value in
+        List.iter (fun id ->
+          add_reference state ~referring_element:element
+            ~attribute:attr ~referenced_id:id ~location
+        ) ids
+
+    | _ -> ()
+  ) attrs
+
+let start_element state ~name ~namespace:_ ~attrs collector =
+  (* For now, we don't have location information from the DOM walker,
+     so we pass None. In a full implementation, this would be passed
+     from the parser. *)
+  let location = None in
+  process_attrs state ~element:name ~attrs ~location collector
+
+let end_element _state ~name:_ ~namespace:_ _collector =
+  ()
+
+let characters _state _text _collector =
+  ()
+
+let end_document state collector =
+  (* Check all references point to existing IDs *)
+  List.iter (fun ref ->
+    if not (Hashtbl.mem state.ids ref.referenced_id) then
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf
+          "The '%s' attribute on <%s> refers to ID '%s' which does not exist"
+          ref.attribute ref.referring_element ref.referenced_id)
+        ~code:"dangling-id-reference"
+        ?location:ref.location
+        ~element:ref.referring_element
+        ~attribute:ref.attribute
+        ()
+  ) state.references
+
+let checker = (module struct
+  type nonrec state = state
+
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/semantic/id_checker.mli

···
+(** ID uniqueness and reference checker.
+
+    Validates:
+    - ID attributes are unique within the document
+    - ID references (for, headers, aria-*, etc.) point to existing IDs
+    - ID values conform to HTML5 requirements *)
+
+include Checker.S
+
+val checker : Checker.t
+(** [checker] is a checker instance for validating ID uniqueness and references. *)

lib/html5_checker/semantic/nesting_checker.ml

···
+(** Interactive element nesting checker implementation. *)
+
+(** Special ancestors that need tracking for nesting validation.
+
+    This array defines the elements whose presence in the ancestor chain
+    affects validation of descendant elements. The order is significant
+    as it determines bit positions in the ancestor bitmask. *)
+let special_ancestors =
+  [| "a"; "address"; "body"; "button"; "caption"; "dfn"; "dt"; "figcaption";
+     "figure"; "footer"; "form"; "header"; "label"; "map"; "noscript"; "th";
+     "time"; "progress"; "meter"; "article"; "section"; "aside"; "nav"; "h1";
+     "h2"; "h3"; "h4"; "h5"; "h6" |]
+
+(** Get the bit position for a special ancestor element.
+    Returns [-1] if the element is not a special ancestor. *)
+let special_ancestor_number name =
+  let rec find i =
+    if i >= Array.length special_ancestors then -1
+    else if special_ancestors.(i) = name then i
+    else find (i + 1)
+  in
+  find 0
+
+(** Interactive elements that cannot be nested inside [a] or [button]. *)
+let interactive_elements =
+  [| "a"; "button"; "details"; "embed"; "iframe"; "label"; "select";
+     "textarea" |]
+
+(** Map from descendant element name to bitmask of prohibited ancestors. *)
+let ancestor_mask_by_descendant : (string, int) Hashtbl.t =
+  Hashtbl.create 64
+
+(** Register that [ancestor] is prohibited for [descendant]. *)
+let register_prohibited_ancestor ancestor descendant =
+  let number = special_ancestor_number ancestor in
+  if number = -1 then
+    failwith ("Ancestor not found in array: " ^ ancestor);
+  let mask =
+    match Hashtbl.find_opt ancestor_mask_by_descendant descendant with
+    | None -> 0
+    | Some m -> m
+  in
+  let new_mask = mask lor (1 lsl number) in
+  Hashtbl.replace ancestor_mask_by_descendant descendant new_mask
+
+(** Initialize the prohibited ancestor map. *)
+let () =
+  (* Self-nesting restrictions *)
+  register_prohibited_ancestor "form" "form";
+  register_prohibited_ancestor "progress" "progress";
+  register_prohibited_ancestor "meter" "meter";
+  register_prohibited_ancestor "dfn" "dfn";
+  register_prohibited_ancestor "noscript" "noscript";
+  register_prohibited_ancestor "label" "label";
+
+  (* Address restrictions *)
+  register_prohibited_ancestor "address" "address";
+  register_prohibited_ancestor "address" "section";
+  register_prohibited_ancestor "address" "nav";
+  register_prohibited_ancestor "address" "article";
+  register_prohibited_ancestor "address" "header";
+  register_prohibited_ancestor "address" "footer";
+  register_prohibited_ancestor "address" "h1";
+  register_prohibited_ancestor "address" "h2";
+  register_prohibited_ancestor "address" "h3";
+  register_prohibited_ancestor "address" "h4";
+  register_prohibited_ancestor "address" "h5";
+  register_prohibited_ancestor "address" "h6";
+
+  (* Header/footer restrictions *)
+  register_prohibited_ancestor "header" "header";
+  register_prohibited_ancestor "footer" "header";
+  register_prohibited_ancestor "header" "footer";
+  register_prohibited_ancestor "footer" "footer";
+
+  (* dt restrictions *)
+  register_prohibited_ancestor "dt" "header";
+  register_prohibited_ancestor "dt" "footer";
+  register_prohibited_ancestor "dt" "article";
+  register_prohibited_ancestor "dt" "nav";
+  register_prohibited_ancestor "dt" "section";
+  register_prohibited_ancestor "dt" "h1";
+  register_prohibited_ancestor "dt" "h2";
+  register_prohibited_ancestor "dt" "h3";
+  register_prohibited_ancestor "dt" "h4";
+  register_prohibited_ancestor "dt" "h5";
+  register_prohibited_ancestor "dt" "h6";
+  register_prohibited_ancestor "dt" "hgroup";
+
+  (* th restrictions *)
+  register_prohibited_ancestor "th" "header";
+  register_prohibited_ancestor "th" "footer";
+  register_prohibited_ancestor "th" "article";
+  register_prohibited_ancestor "th" "nav";
+  register_prohibited_ancestor "th" "section";
+  register_prohibited_ancestor "th" "h1";
+  register_prohibited_ancestor "th" "h2";
+  register_prohibited_ancestor "th" "h3";
+  register_prohibited_ancestor "th" "h4";
+  register_prohibited_ancestor "th" "h5";
+  register_prohibited_ancestor "th" "h6";
+  register_prohibited_ancestor "th" "hgroup";
+
+  (* Caption restriction *)
+  register_prohibited_ancestor "caption" "table";
+
+  (* Interactive element restrictions: cannot be inside a or button *)
+  Array.iter (fun elem ->
+    register_prohibited_ancestor "a" elem;
+    register_prohibited_ancestor "button" elem
+  ) interactive_elements
+
+(** Bitmask constants for common checks. *)
+let a_button_mask =
+  let a_num = special_ancestor_number "a" in
+  let button_num = special_ancestor_number "button" in
+  (1 lsl a_num) lor (1 lsl button_num)
+
+let map_mask =
+  let map_num = special_ancestor_number "map" in
+  1 lsl map_num
+
+(** Stack node representing an element's context. *)
+type stack_node = {
+  ancestor_mask : int;
+  _name : string;  [@warning "-69"]
+}
+
+(** Checker state. *)
+type state = {
+  mutable stack : stack_node list;
+  mutable ancestor_mask : int;
+}
+
+let create () =
+  { stack = []; ancestor_mask = 0 }
+
+let reset state =
+  state.stack <- [];
+  state.ancestor_mask <- 0
+
+(** Get attribute value by name from attribute list. *)
+let get_attr attrs name =
+  List.assoc_opt name attrs
+
+(** Check if an attribute exists. *)
+let has_attr attrs name =
+  get_attr attrs name <> None
+
+(** Check if element is interactive based on its attributes. *)
+let is_interactive_element name attrs =
+  match name with
+  | "a" ->
+      has_attr attrs "href"
+  | "audio" | "video" ->
+      has_attr attrs "controls"
+  | "img" | "object" ->
+      has_attr attrs "usemap"
+  | "input" ->
+      begin match get_attr attrs "type" with
+      | Some "hidden" -> false
+      | _ -> true
+      end
+  | "button" | "details" | "embed" | "iframe" | "label" | "select"
+  | "textarea" ->
+      true
+  | _ ->
+      false
+
+(** Get a human-readable description of an element for error messages. *)
+let element_description name attrs =
+  match name with
+  | "a" when has_attr attrs "href" ->
+      "The element \"a\" with the attribute \"href\""
+  | "audio" when has_attr attrs "controls" ->
+      "The element \"audio\" with the attribute \"controls\""
+  | "video" when has_attr attrs "controls" ->
+      "The element \"video\" with the attribute \"controls\""
+  | "img" when has_attr attrs "usemap" ->
+      "The element \"img\" with the attribute \"usemap\""
+  | "object" when has_attr attrs "usemap" ->
+      "The element \"object\" with the attribute \"usemap\""
+  | _ ->
+      Printf.sprintf "The element \"%s\"" name
+
+(** Report nesting violations. *)
+let check_nesting state name attrs collector =
+  (* Compute the prohibited ancestor mask for this element *)
+  let base_mask =
+    match Hashtbl.find_opt ancestor_mask_by_descendant name with
+    | Some m -> m
+    | None -> 0
+  in
+
+  (* Add interactive element restrictions if applicable *)
+  let mask =
+    if is_interactive_element name attrs then
+      base_mask lor a_button_mask
+    else
+      base_mask
+  in
+
+  (* Check for violations *)
+  if mask <> 0 then begin
+    let mask_hit = state.ancestor_mask land mask in
+    if mask_hit <> 0 then begin
+      let desc = element_description name attrs in
+      (* Find which ancestors are violated *)
+      Array.iteri (fun i ancestor ->
+        let bit = 1 lsl i in
+        if (mask_hit land bit) <> 0 then
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf
+              "%s must not appear as a descendant of the \"%s\" element."
+              desc ancestor)
+            ~element:name
+            ()
+      ) special_ancestors
+    end
+  end
+
+(** Check for required ancestors. *)
+let check_required_ancestors state name collector =
+  match name with
+  | "area" ->
+      if (state.ancestor_mask land map_mask) = 0 then
+        Message_collector.add_error collector
+          ~message:"The \"area\" element must have a \"map\" ancestor."
+          ~element:name
+          ()
+  | _ -> ()
+
+let start_element state ~name ~namespace ~attrs collector =
+  (* Only check HTML elements, not SVG or MathML *)
+  match namespace with
+  | Some _ -> ()
+  | None ->
+      (* Check for nesting violations *)
+      check_nesting state name attrs collector;
+      check_required_ancestors state name collector;
+
+      (* Update ancestor mask if this is a special ancestor *)
+      let new_mask = state.ancestor_mask in
+      let number = special_ancestor_number name in
+      let new_mask =
+        if number >= 0 then
+          new_mask lor (1 lsl number)
+        else
+          new_mask
+      in
+
+      (* Add href tracking for <a> elements *)
+      let new_mask =
+        if name = "a" && has_attr attrs "href" then
+          let a_num = special_ancestor_number "a" in
+          new_mask lor (1 lsl a_num)
+        else
+          new_mask
+      in
+
+      (* Push onto stack *)
+      let node = { ancestor_mask = state.ancestor_mask; _name = name } in
+      state.stack <- node :: state.stack;
+      state.ancestor_mask <- new_mask
+
+let end_element state ~name:_ ~namespace _collector =
+  (* Only track HTML elements *)
+  match namespace with
+  | Some _ -> ()
+  | None ->
+      (* Pop from stack and restore ancestor mask *)
+      begin match state.stack with
+      | [] -> ()  (* Should not happen in well-formed documents *)
+      | node :: rest ->
+          state.stack <- rest;
+          state.ancestor_mask <- node.ancestor_mask
+      end
+
+let characters _state _text _collector =
+  ()  (* No text-specific nesting checks *)
+
+let end_document _state _collector =
+  ()  (* No document-level checks needed *)
+
+(** Create the checker as a first-class module. *)
+let checker =
+  let module M = struct
+    type nonrec state = state
+    let create = create
+    let reset = reset
+    let start_element = start_element
+    let end_element = end_element
+    let characters = characters
+    let end_document = end_document
+  end in
+  (module M : Checker.S)

lib/html5_checker/semantic/nesting_checker.mli

···
+(** Interactive element nesting checker.
+
+    Validates that interactive elements are not nested in ways that violate
+    HTML5 specifications. This checker tracks ancestor elements and ensures
+    that prohibited nesting patterns are detected and reported.
+
+    {2 Validation Rules}
+
+    The checker enforces the following prohibited nesting relationships:
+
+    {3 Self-nesting Restrictions}
+
+    These elements cannot be nested inside themselves:
+    - [form] cannot contain [form]
+    - [progress] cannot contain [progress]
+    - [meter] cannot contain [meter]
+    - [dfn] cannot contain [dfn]
+    - [noscript] cannot contain [noscript]
+    - [label] cannot contain [label]
+
+    {3 Structural Element Restrictions}
+
+    - [header] cannot be inside [header], [footer], or [address]
+    - [footer] cannot be inside [header], [footer], or [address]
+    - [address] cannot contain [header], [footer], [article], [section],
+      [nav], or heading elements ([h1]-[h6])
+
+    {3 Interactive Content Restrictions}
+
+    Interactive elements cannot be descendants of [a] (with [href]) or
+    [button]:
+
+    - [a] (when it has [href]) cannot be inside [a] or [button]
+    - [button] cannot be inside [a] or [button]
+    - [details] cannot be inside [a] or [button]
+    - [embed] cannot be inside [a] or [button]
+    - [iframe] cannot be inside [a] or [button]
+    - [label] cannot be inside [a] or [button]
+    - [select] cannot be inside [a] or [button]
+    - [textarea] cannot be inside [a] or [button]
+    - [audio] (with [controls]) cannot be inside [a] or [button]
+    - [video] (with [controls]) cannot be inside [a] or [button]
+    - [input] (except [type=hidden]) cannot be inside [a] or [button]
+    - [img] (with [usemap]) cannot be inside [a] or [button]
+    - [object] (with [usemap]) cannot be inside [a] or [button]
+
+    {3 Table Cell Restrictions}
+
+    - [dt] and [th] cannot contain [header], [footer], [article], [section],
+      [nav], heading elements ([h1]-[h6]), or [hgroup]
+
+    {3 Other Restrictions}
+
+    - [caption] cannot contain [table]
+    - [area] must have a [map] ancestor
+
+    {2 Implementation Details}
+
+    The checker uses a bitmask-based approach to efficiently track ancestor
+    elements. Each "special" ancestor element has a corresponding bit in the
+    ancestor mask. As elements are opened and closed during traversal, the
+    mask is updated to reflect the current ancestor context.
+
+    When an element is encountered, the checker:
+    1. Computes which ancestors would be prohibited for this element
+    2. Checks if any of those prohibited ancestors are present in the
+       current ancestor mask
+    3. Reports errors for any violations found
+    4. Updates the ancestor mask to include the current element (if it's
+       a special ancestor)
+
+    @see <https://html.spec.whatwg.org/multipage/dom.html#content-models>
+         HTML5 specification: Content models
+*)
+
+include Checker.S
+
+val checker : Checker.t
+(** [checker] is a checker instance for validating element nesting rules. *)

lib/html5_checker/semantic/obsolete_checker.ml

···
+(** Obsolete elements map: element name -> suggestion message *)
+let obsolete_elements =
+  let tbl = Hashtbl.create 32 in
+  Hashtbl.add tbl "applet" "Use \"embed\" or \"object\" element instead.";
+  Hashtbl.add tbl "acronym" "Use the \"abbr\" element instead.";
+  Hashtbl.add tbl "bgsound" "Use the \"audio\" element instead.";
+  Hashtbl.add tbl "dir" "Use the \"ul\" element instead.";
+  Hashtbl.add tbl "frame" "Use the \"iframe\" element and CSS instead, or use server-side includes.";
+  Hashtbl.add tbl "frameset" "Use the \"iframe\" element and CSS instead, or use server-side includes.";
+  Hashtbl.add tbl "noframes" "Use the \"iframe\" element and CSS instead, or use server-side includes.";
+  Hashtbl.add tbl "isindex" "Use the \"form\" element containing \"input\" element of type \"text\" instead.";
+  Hashtbl.add tbl "keygen" "";
+  Hashtbl.add tbl "listing" "Use \"pre\" or \"code\" element instead.";
+  Hashtbl.add tbl "menuitem" "Use script to handle \"contextmenu\" event instead.";
+  Hashtbl.add tbl "nextid" "Use GUIDs instead.";
+  Hashtbl.add tbl "noembed" "Use the \"object\" element instead.";
+  Hashtbl.add tbl "param" "Use the \"data\" attribute of the \"object\" element to set the URL of the external resource.";
+  Hashtbl.add tbl "plaintext" "Use the \"text/plain\" MIME type instead.";
+  Hashtbl.add tbl "rb" "";
+  Hashtbl.add tbl "rtc" "";
+  Hashtbl.add tbl "strike" "Use \"del\" or \"s\" element instead.";
+  Hashtbl.add tbl "xmp" "Use \"pre\" or \"code\" element instead.";
+  Hashtbl.add tbl "basefont" "Use CSS instead.";
+  Hashtbl.add tbl "big" "Use CSS instead.";
+  Hashtbl.add tbl "blink" "Use CSS instead.";
+  Hashtbl.add tbl "center" "Use CSS instead.";
+  Hashtbl.add tbl "font" "Use CSS instead.";
+  Hashtbl.add tbl "marquee" "Use CSS instead.";
+  Hashtbl.add tbl "multicol" "Use CSS instead.";
+  Hashtbl.add tbl "nobr" "Use CSS instead.";
+  Hashtbl.add tbl "spacer" "Use CSS instead.";
+  Hashtbl.add tbl "tt" "Use CSS instead.";
+  tbl
+
+(** Obsolete attributes map: attr_name -> (element_name -> suggestion message) *)
+let obsolete_attributes =
+  let tbl = Hashtbl.create 64 in
+
+  (* Helper to register an attribute for multiple elements *)
+  let register attr_name elements suggestion =
+    let element_map =
+      match Hashtbl.find_opt tbl attr_name with
+      | Some m -> m
+      | None ->
+          let m = Hashtbl.create 16 in
+          Hashtbl.add tbl attr_name m;
+          m
+    in
+    List.iter (fun elem -> Hashtbl.add element_map elem suggestion) elements
+  in
+
+  register "abbr" ["td"]
+    "Consider instead beginning the cell contents with concise text, followed by further elaboration if needed.";
+
+  register "accept" ["form"]
+    "Use the \"accept\" attribute directly on the \"input\" elements instead.";
+
+  register "archive" ["object"]
+    "Use the \"data\" and \"type\" attributes to invoke plugins.";
+
+  register "a" ["object"]
+    "Use the \"data\" and \"type\" attributes to invoke plugins.";
+
+  register "axis" ["td"; "th"]
+    "Use the \"scope\" attribute.";
+
+  register "border" ["input"; "img"; "object"; "table"]
+    "Consider specifying \"img { border: 0; }\" in CSS instead.";
+
+  register "charset" ["a"; "link"]
+    "Use an HTTP Content-Type header on the linked resource instead.";
+
+  register "classid" ["object"]
+    "Use the \"data\" and \"type\" attributes to invoke plugins.";
+
+  register "code" ["object"]
+    "Use the \"data\" and \"type\" attributes to invoke plugins.";
+
+  register "codebase" ["object"]
+    "Use the \"data\" and \"type\" attributes to invoke plugins.";
+
+  register "codetype" ["object"]
+    "Use the \"data\" and \"type\" attributes to invoke plugins.";
+
+  register "coords" ["a"]
+    "Use \"area\" instead of \"a\" for image maps.";
+
+  register "datafld" ["a"; "button"; "div"; "fieldset"; "iframe"; "img"; "input"; "label"; "legend"; "object"; "select"; "span"; "textarea"]
+    "Use script and a mechanism such as XMLHttpRequest to populate the page dynamically";
+
+  register "dataformatas" ["button"; "div"; "input"; "label"; "legend"; "object"; "option"; "select"; "span"; "table"]
+    "Use script and a mechanism such as XMLHttpRequest to populate the page dynamically";
+
+  register "datapagesize" ["table"]
+    "You can safely omit it.";
+
+  register "datasrc" ["a"; "button"; "div"; "iframe"; "img"; "input"; "label"; "legend"; "object"; "option"; "select"; "span"; "table"; "textarea"]
+    "Use script and a mechanism such as XMLHttpRequest to populate the page dynamically";
+
+  register "declare" ["object"]
+    "Repeat the \"object\" element completely each time the resource is to be reused.";
+
+  register "event" ["script"]
+    "Use DOM Events mechanisms to register event listeners.";
+
+  register "for" ["script"]
+    "Use DOM Events mechanisms to register event listeners.";
+
+  register "hreflang" ["area"]
+    "You can safely omit it.";
+
+  register "ismap" ["input"]
+    "You can safely omit it.";
+
+  register "label" ["menu"]
+    "Use script to handle \"contextmenu\" event instead.";
+
+  register "language" ["script"]
+    "Use the \"type\" attribute instead.";
+
+  register "longdesc" ["iframe"; "img"]
+    "Use a regular \"a\" element to link to the description.";
+
+  register "lowsrc" ["img"]
+    "Use a progressive JPEG image instead.";
+
+  register "manifest" ["html"]
+    "Use service workers instead.";
+
+  register "methods" ["a"; "link"]
+    "Use the HTTP OPTIONS feature instead.";
+
+  register "name" ["a"; "embed"; "img"; "option"]
+    "Use the \"id\" attribute instead.";
+
+  register "nohref" ["area"]
+    "Omitting the \"href\" attribute is sufficient.";
+
+  register "profile" ["head"]
+    "To declare which \"meta\" terms are used in the document, instead register the names as meta extensions. To trigger specific UA behaviors, use a \"link\" element instead.";
+
+  register "scheme" ["meta"]
+    "Use only one scheme per field, or make the scheme declaration part of the value.";
+
+  register "scope" ["td"]
+    "Use the \"scope\" attribute on a \"th\" element instead.";
+
+  register "shape" ["a"]
+    "Use \"area\" instead of \"a\" for image maps.";
+
+  register "standby" ["object"]
+    "Optimise the linked resource so that it loads quickly or, at least, incrementally.";
+
+  register "summary" ["table"]
+    "Consider describing the structure of the \"table\" in a \"caption\" element or in a \"figure\" element containing the \"table\"; or, simplify the structure of the \"table\" so that no description is needed.";
+
+  register "target" ["link"]
+    "You can safely omit it.";
+
+  register "type" ["param"; "area"; "menu"]
+    "You can safely omit it.";
+
+  register "typemustmatch" ["object"]
+    "Avoid using \"object\" elements with untrusted resources.";
+
+  register "urn" ["a"; "link"]
+    "Specify the preferred persistent identifier using the \"href\" attribute instead.";
+
+  register "usemap" ["input"; "object"]
+    "Use the \"img\" element instead.";
+
+  register "valuetype" ["param"]
+    "Use the \"name\" and \"value\" attributes without declaring value types.";
+
+  register "version" ["html"]
+    "You can safely omit it.";
+
+  tbl
+
+(** Obsolete style attributes map: attr_name -> element_name list *)
+let obsolete_style_attrs =
+  let tbl = Hashtbl.create 64 in
+
+  let register attr_name elements =
+    Hashtbl.add tbl attr_name elements
+  in
+
+  register "align" ["caption"; "iframe"; "img"; "input"; "object"; "embed"; "legend"; "table"; "hr"; "div"; "h1"; "h2"; "h3"; "h4"; "h5"; "h6"; "p"; "col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"];
+  register "alink" ["body"];
+  register "allowtransparency" ["iframe"];
+  register "background" ["body"; "table"; "thead"; "tbody"; "tfoot"; "tr"; "td"; "th"];
+  register "bgcolor" ["table"; "tr"; "td"; "th"; "body"];
+  register "bordercolor" ["table"];
+  register "cellpadding" ["table"];
+  register "cellspacing" ["table"];
+  register "char" ["col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"];
+  register "charoff" ["col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"];
+  register "clear" ["br"];
+  register "color" ["hr"];
+  register "compact" ["dl"; "menu"; "ol"; "ul"];
+  register "frameborder" ["iframe"];
+  register "framespacing" ["iframe"];
+  register "frame" ["table"];
+  register "height" ["table"; "thead"; "tbody"; "tfoot"; "tr"; "td"; "th"];
+  register "hspace" ["embed"; "iframe"; "input"; "img"; "object"];
+  register "link" ["body"];
+  register "bottommargin" ["body"];
+  register "marginheight" ["iframe"; "body"];
+  register "leftmargin" ["body"];
+  register "rightmargin" ["body"];
+  register "topmargin" ["body"];
+  register "marginwidth" ["iframe"; "body"];
+  register "noshade" ["hr"];
+  register "nowrap" ["td"; "th"];
+  register "rules" ["table"];
+  register "scrolling" ["iframe"];
+  register "size" ["hr"];
+  register "text" ["body"];
+  register "type" ["li"; "ul"];
+  register "valign" ["col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"];
+  register "vlink" ["body"];
+  register "vspace" ["embed"; "iframe"; "input"; "img"; "object"];
+  register "width" ["hr"; "table"; "td"; "th"; "col"; "colgroup"; "pre"];
+
+  tbl
+
+(** Obsolete global attributes map: attr_name -> suggestion message *)
+let obsolete_global_attrs =
+  let tbl = Hashtbl.create 8 in
+  Hashtbl.add tbl "contextmenu" "Use script to handle \"contextmenu\" event instead.";
+  Hashtbl.add tbl "dropzone" "Use script to handle the \"dragenter\" and \"dragover\" events instead.";
+  Hashtbl.add tbl "onshow" "Use script to handle \"contextmenu\" event instead.";
+  tbl
+
+(** Checker state *)
+type state = unit
+
+let create () = ()
+
+let reset _state = ()
+
+let start_element _state ~name ~namespace ~attrs collector =
+  (* Only check HTML elements (no namespace or explicit HTML namespace) *)
+  let is_html = match namespace with
+    | None -> true
+    | Some ns -> String.equal (String.lowercase_ascii ns) "html"
+  in
+
+  if not is_html then ()
+  else begin
+    let name_lower = String.lowercase_ascii name in
+
+    (* Check for obsolete element *)
+    (match Hashtbl.find_opt obsolete_elements name_lower with
+    | None -> ()
+    | Some suggestion ->
+        let message =
+          if String.length suggestion = 0 then
+            Printf.sprintf "The \"%s\" element is obsolete." name
+          else
+            Printf.sprintf "The \"%s\" element is obsolete. %s" name suggestion
+        in
+        Message_collector.add_error collector
+          ~message
+          ~code:"obsolete-element"
+          ~element:name
+          ());
+
+    (* Check for obsolete attributes *)
+    List.iter (fun (attr_name, _attr_value) ->
+      let attr_lower = String.lowercase_ascii attr_name in
+
+      (* Check specific obsolete attributes for this element *)
+      (match Hashtbl.find_opt obsolete_attributes attr_lower with
+      | None -> ()
+      | Some element_map ->
+          (match Hashtbl.find_opt element_map name_lower with
+          | None -> ()
+          | Some suggestion ->
+              let message =
+                Printf.sprintf "The \"%s\" attribute on the \"%s\" element is obsolete. %s"
+                  attr_name name suggestion
+              in
+              Message_collector.add_error collector
+                ~message
+                ~code:"obsolete-attribute"
+                ~element:name
+                ~attribute:attr_name
+                ()));
+
+      (* Check obsolete style attributes *)
+      (match Hashtbl.find_opt obsolete_style_attrs attr_lower with
+      | None -> ()
+      | Some elements ->
+          if List.mem name_lower elements then
+            let message =
+              Printf.sprintf "The \"%s\" attribute on the \"%s\" element is obsolete. Use CSS instead."
+                attr_name name
+            in
+            Message_collector.add_error collector
+              ~message
+              ~code:"obsolete-style-attribute"
+              ~element:name
+              ~attribute:attr_name
+              ());
+
+      (* Check obsolete global attributes *)
+      (match Hashtbl.find_opt obsolete_global_attrs attr_lower with
+      | None -> ()
+      | Some suggestion ->
+          let message =
+            Printf.sprintf "The \"%s\" attribute is obsolete. %s" attr_name suggestion
+          in
+          Message_collector.add_error collector
+            ~message
+            ~code:"obsolete-global-attribute"
+            ~element:name
+            ~attribute:attr_name
+            ())
+    ) attrs
+  end
+
+let end_element _state ~name:_ ~namespace:_ _collector = ()
+
+let characters _state _text _collector = ()
+
+let end_document _state _collector = ()
+
+let checker =
+  let module M = struct
+    type nonrec state = state
+    let create = create
+    let reset = reset
+    let start_element = start_element
+    let end_element = end_element
+    let characters = characters
+    let end_document = end_document
+  end in
+  (module M : Checker.S)

lib/html5_checker/semantic/obsolete_checker.mli

···
+(** Obsolete element and attribute checker.
+
+    Reports errors for obsolete HTML elements and attributes that should
+    not be used in modern HTML5 documents.
+
+    This checker validates that documents do not use deprecated elements
+    or attributes from earlier HTML versions. It reports:
+
+    - {b Obsolete elements}: Elements like [<applet>], [<font>], [<center>]
+      that have been removed from HTML5
+    - {b Obsolete attributes}: Attributes like [align], [bgcolor], [border]
+      that should be replaced with CSS
+    - {b Obsolete global attributes}: Global attributes like [contextmenu]
+      that are no longer supported
+
+    {2 Obsolete Elements}
+
+    Elements that are flagged as obsolete include:
+    - Presentational elements: [<basefont>], [<big>], [<center>], [<font>],
+      [<strike>], [<tt>]
+    - Frame elements: [<frame>], [<frameset>], [<noframes>]
+    - Deprecated interactive elements: [<applet>], [<bgsound>], [<keygen>]
+    - Deprecated text elements: [<acronym>], [<dir>], [<listing>], [<xmp>]
+    - And many others
+
+    {2 Obsolete Attributes}
+
+    The checker validates against hundreds of obsolete attributes, including:
+    - Presentational attributes: [align], [bgcolor], [border], [color],
+      [height], [width] (on certain elements)
+    - Data binding attributes: [datafld], [dataformatas], [datasrc]
+    - Navigation attributes: [longdesc], [methods], [urn]
+    - And many element-specific obsolete attributes
+
+    {2 Example}
+
+    {[
+      let checker = Obsolete_checker.checker in
+      let module C = (val checker : Checker.S) in
+      let state = C.create () in
+
+      (* This will emit an error *)
+      C.start_element state ~name:"center" ~namespace:None ~attrs:[] collector;
+      (* Error: Element "center" is obsolete. Use CSS instead. *)
+
+      (* This will also emit an error *)
+      C.start_element state ~name:"div"
+        ~namespace:None
+        ~attrs:[("align", "center")]
+        collector;
+      (* Error: Attribute "align" on element "div" is obsolete. Use CSS instead. *)
+    ]}
+*)
+
+(** Include the standard checker signature. *)
+include Checker.S
+
+(** {1 Checker Instance} *)
+
+val checker : Checker.t
+(** [checker] is a pre-configured obsolete checker instance that can be
+    registered with the checker registry.
+
+    {b Example:}
+    {[
+      Checker_registry.register registry "obsolete" Obsolete_checker.checker
+    ]} *)

lib/html5_checker/semantic/required_attr_checker.ml

···
+(** Required attribute checker implementation. *)
+
+type state = {
+  mutable _in_figure : bool;
+  (** Track if we're inside a <figure> element (alt is more critical there) *)
+}
+
+let create () = { _in_figure = false }
+
+let reset state = state._in_figure <- false
+
+(** Check if an attribute list contains a specific attribute. *)
+let has_attr name attrs =
+  List.exists (fun (attr_name, _) -> String.equal attr_name name) attrs
+
+(** Get the value of an attribute if present. *)
+let get_attr name attrs =
+  List.find_map
+    (fun (attr_name, value) ->
+      if String.equal attr_name name then Some value else None)
+    attrs
+
+let check_img_element attrs collector =
+  (* Check for required src attribute *)
+  if not (has_attr "src" attrs) then
+    Message_collector.add_error collector ~message:"img element requires src attribute"
+      ~code:"missing-required-attribute" ~element:"img" ~attribute:"src" ();
+
+  (* Check for alt attribute - always required *)
+  if not (has_attr "alt" attrs) then
+    Message_collector.add_error collector
+      ~message:"img element requires alt attribute for accessibility"
+      ~code:"missing-required-attribute" ~element:"img" ~attribute:"alt" ()
+
+let check_area_element attrs collector =
+  (* area with href requires alt *)
+  if has_attr "href" attrs && not (has_attr "alt" attrs) then
+    Message_collector.add_error collector
+      ~message:"area element with href requires alt attribute" ~code:"missing-required-attribute"
+      ~element:"area" ~attribute:"alt" ()
+
+let check_input_element attrs collector =
+  match get_attr "type" attrs with
+  | Some "image" ->
+      (* input[type=image] requires alt *)
+      if not (has_attr "alt" attrs) then
+        Message_collector.add_error collector
+          ~message:"input element with type=\"image\" requires alt attribute"
+          ~code:"missing-required-attribute" ~element:"input" ~attribute:"alt" ()
+  | Some "hidden" ->
+      (* input[type=hidden] should not have required attribute *)
+      if has_attr "required" attrs then
+        Message_collector.add_error collector
+          ~message:"input element with type=\"hidden\" cannot have required attribute"
+          ~code:"invalid-attribute-combination" ~element:"input" ~attribute:"required" ()
+  | Some "file" ->
+      (* input[type=file] should not have value attribute *)
+      if has_attr "value" attrs then
+        Message_collector.add_warning collector
+          ~message:"input element with type=\"file\" should not have value attribute"
+          ~code:"invalid-attribute-combination" ~element:"input" ~attribute:"value" ()
+  | _ -> ()
+
+let check_script_element attrs _collector =
+  (* script requires src OR text content *)
+  if not (has_attr "src" attrs) then
+    (* We can't check for text content here; that would need to be done
+       in end_element or with state tracking *)
+    ()
+
+let check_meta_element attrs collector =
+  (* meta requires charset OR (name AND content) OR (http-equiv AND content) *)
+  let has_charset = has_attr "charset" attrs in
+  let has_name = has_attr "name" attrs in
+  let has_content = has_attr "content" attrs in
+  let has_http_equiv = has_attr "http-equiv" attrs in
+
+  let valid =
+    has_charset
+    || (has_name && has_content)
+    || (has_http_equiv && has_content)
+  in
+
+  if not valid then
+    Message_collector.add_error collector
+      ~message:
+        "meta element requires either charset, or name+content, or http-equiv+content"
+      ~code:"missing-required-attribute" ~element:"meta" ()
+
+let check_link_element attrs collector =
+  (* link[rel="stylesheet"] requires href *)
+  match get_attr "rel" attrs with
+  | Some rel when String.equal rel "stylesheet" ->
+      if not (has_attr "href" attrs) then
+        Message_collector.add_error collector
+          ~message:"link element with rel=\"stylesheet\" requires href attribute"
+          ~code:"missing-required-attribute" ~element:"link" ~attribute:"href" ()
+  | _ -> ()
+
+let check_a_element attrs collector =
+  (* a[download] requires href *)
+  if has_attr "download" attrs && not (has_attr "href" attrs) then
+    Message_collector.add_error collector
+      ~message:"a element with download attribute requires href attribute"
+      ~code:"missing-required-attribute" ~element:"a" ~attribute:"href" ()
+
+let check_map_element attrs collector =
+  (* map requires name *)
+  if not (has_attr "name" attrs) then
+    Message_collector.add_error collector
+      ~message:"map element requires name attribute" ~code:"missing-required-attribute"
+      ~element:"map" ~attribute:"name" ()
+
+let start_element state ~name ~namespace:_ ~attrs collector =
+  match name with
+  | "img" -> check_img_element attrs collector
+  | "area" -> check_area_element attrs collector
+  | "input" -> check_input_element attrs collector
+  | "script" -> check_script_element attrs collector
+  | "meta" -> check_meta_element attrs collector
+  | "link" -> check_link_element attrs collector
+  | "a" -> check_a_element attrs collector
+  | "map" -> check_map_element attrs collector
+  | "figure" -> state._in_figure <- true
+  | _ -> ()
+
+let end_element state ~name ~namespace:_ _collector =
+  match name with "figure" -> state._in_figure <- false | _ -> ()
+
+let characters _state _text _collector = ()
+
+let end_document _state _collector = ()
+
+let checker = (module struct
+  type nonrec state = state
+
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/semantic/required_attr_checker.mli

···
+(** Required attribute checker.
+
+    Validates that elements have their required attributes according to the
+    HTML5 specification. This checker ensures that:
+
+    - Elements have all mandatory attributes
+    - Conditional attributes are present when required by context
+    - Attributes that must appear together are all present
+
+    {2 Validation Rules}
+
+    The checker validates these common required attributes:
+
+    {b Images and Media}
+    - [img] requires [src] attribute
+    - [img] requires [alt] attribute (error in most contexts, warning otherwise)
+    - [area] with [href] requires [alt] attribute
+    - [input\[type=image\]] requires [alt] attribute
+
+    {b Forms}
+    - [input] defaults to [type="text"] if [type] is omitted
+    - [map] requires [name] attribute
+
+    {b Scripts and Styles}
+    - [script] requires either [src] attribute OR text content
+    - [style] with [scoped] requires appropriate positioning
+
+    {b Metadata}
+    - [meta] requires one of:
+      - [charset] attribute, OR
+      - [name] and [content] attributes, OR
+      - [http-equiv] and [content] attributes
+    - [link\[rel="stylesheet"\]] requires [href] attribute
+
+    {b Links}
+    - [a] with [download] attribute requires [href] attribute
+
+    @see <https://html.spec.whatwg.org/multipage/indices.html#attributes-3>
+         WHATWG HTML: Attributes *)
+
+include Checker.S
+
+val checker : Checker.t
+(** A first-class module instance of this checker.
+
+    {b Usage:}
+    {[
+      let checker = Required_attr_checker.checker in
+      Checker_registry.register "required-attributes" checker
+    ]} *)

lib/html5_checker/specialized/aria_checker.ml

···
+(** ARIA validation checker implementation. *)
+
+(** Valid WAI-ARIA 1.2 roles.
+
+    These are all the valid role values according to the WAI-ARIA 1.2
+    specification. Abstract roles are included but should not be used
+    in HTML content. *)
+let valid_aria_roles =
+  let roles = [
+    (* Document structure roles *)
+    "article"; "associationlist"; "associationlistitemkey";
+    "associationlistitemvalue"; "blockquote"; "caption"; "cell"; "code";
+    "definition"; "deletion"; "directory"; "document"; "emphasis"; "feed";
+    "figure"; "generic"; "group"; "heading"; "img"; "insertion"; "list";
+    "listitem"; "mark"; "math"; "meter"; "none"; "note"; "paragraph";
+    "presentation"; "row"; "rowgroup"; "strong"; "subscript"; "suggestion";
+    "superscript"; "table"; "term"; "time"; "toolbar"; "tooltip";
+
+    (* Widget roles *)
+    "button"; "checkbox"; "combobox"; "dialog"; "grid"; "gridcell"; "link";
+    "listbox"; "menu"; "menubar"; "menuitem"; "menuitemcheckbox";
+    "menuitemradio"; "option"; "progressbar"; "radio"; "radiogroup";
+    "scrollbar"; "searchbox"; "separator"; "slider"; "spinbutton"; "switch";
+    "tab"; "tablist"; "tabpanel"; "textbox"; "tree"; "treegrid"; "treeitem";
+
+    (* Landmark roles *)
+    "banner"; "complementary"; "contentinfo"; "form"; "main"; "navigation";
+    "region"; "search";
+
+    (* Live region roles *)
+    "alert"; "log"; "marquee"; "status"; "timer";
+
+    (* Window roles *)
+    "alertdialog";
+
+    (* Abstract roles - not for use in HTML content *)
+    "command"; "comment"; "composite"; "input"; "landmark"; "range";
+    "roletype"; "section"; "sectionhead"; "select"; "structure"; "widget";
+    "window";
+
+    (* Additional roles *)
+    "application"; "columnheader"; "rowheader";
+  ] in
+  let tbl = Hashtbl.create (List.length roles) in
+  List.iter (fun role -> Hashtbl.add tbl role ()) roles;
+  tbl
+
+(** Roles that cannot have accessible names.
+
+    These roles must not have aria-label or aria-labelledby attributes. *)
+let roles_which_cannot_be_named =
+  let roles = [
+    "caption"; "code"; "deletion"; "emphasis"; "generic"; "insertion";
+    "paragraph"; "presentation"; "strong"; "subscript"; "superscript"
+  ] in
+  let tbl = Hashtbl.create (List.length roles) in
+  List.iter (fun role -> Hashtbl.add tbl role ()) roles;
+  tbl
+
+(** Map from descendant role to set of required ancestor roles. *)
+let required_role_ancestor_by_descendant : (string, string list) Hashtbl.t =
+  Hashtbl.create 32
+
+(** Register that a descendant role requires one of the given ancestor roles. *)
+let register_required_ancestor_role parents child =
+  Hashtbl.add required_role_ancestor_by_descendant child parents
+
+(** Initialize required ancestor role relationships. *)
+let () =
+  register_required_ancestor_role ["listbox"] "option";
+  register_required_ancestor_role ["menu"; "menubar"] "menuitem";
+  register_required_ancestor_role ["menu"; "menubar"] "menuitemcheckbox";
+  register_required_ancestor_role ["menu"; "menubar"] "menuitemradio";
+  register_required_ancestor_role ["tablist"] "tab";
+  register_required_ancestor_role ["tree"; "group"] "treeitem";
+  register_required_ancestor_role ["list"; "group"] "listitem";
+  register_required_ancestor_role ["row"] "cell";
+  register_required_ancestor_role ["row"] "gridcell";
+  register_required_ancestor_role ["row"] "columnheader";
+  register_required_ancestor_role ["row"] "rowheader";
+  register_required_ancestor_role ["grid"; "rowgroup"; "table"; "treegrid"] "row";
+  register_required_ancestor_role ["grid"; "table"; "treegrid"] "rowgroup"
+
+(** Map from HTML element name to implicit ARIA role. *)
+let elements_with_implicit_role : (string, string) Hashtbl.t =
+  let tbl = Hashtbl.create 64 in
+  Hashtbl.add tbl "article" "article";
+  Hashtbl.add tbl "aside" "complementary";
+  Hashtbl.add tbl "body" "document";
+  Hashtbl.add tbl "button" "button";
+  Hashtbl.add tbl "datalist" "listbox";
+  Hashtbl.add tbl "dd" "definition";
+  Hashtbl.add tbl "details" "group";
+  Hashtbl.add tbl "dialog" "dialog";
+  Hashtbl.add tbl "dfn" "term";
+  Hashtbl.add tbl "dt" "term";
+  Hashtbl.add tbl "fieldset" "group";
+  Hashtbl.add tbl "figure" "figure";
+  Hashtbl.add tbl "form" "form";
+  Hashtbl.add tbl "footer" "contentinfo";
+  Hashtbl.add tbl "h1" "heading";
+  Hashtbl.add tbl "h2" "heading";
+  Hashtbl.add tbl "h3" "heading";
+  Hashtbl.add tbl "h4" "heading";
+  Hashtbl.add tbl "h5" "heading";
+  Hashtbl.add tbl "h6" "heading";
+  Hashtbl.add tbl "hr" "separator";
+  Hashtbl.add tbl "header" "banner";
+  Hashtbl.add tbl "img" "img";
+  Hashtbl.add tbl "li" "listitem";
+  Hashtbl.add tbl "link" "link";
+  Hashtbl.add tbl "main" "main";
+  Hashtbl.add tbl "nav" "navigation";
+  Hashtbl.add tbl "ol" "list";
+  Hashtbl.add tbl "output" "status";
+  Hashtbl.add tbl "progress" "progressbar";
+  Hashtbl.add tbl "section" "region";
+  Hashtbl.add tbl "summary" "button";
+  Hashtbl.add tbl "s" "deletion";
+  Hashtbl.add tbl "table" "table";
+  Hashtbl.add tbl "tbody" "rowgroup";
+  Hashtbl.add tbl "textarea" "textbox";
+  Hashtbl.add tbl "tfoot" "rowgroup";
+  Hashtbl.add tbl "thead" "rowgroup";
+  Hashtbl.add tbl "td" "cell";
+  Hashtbl.add tbl "tr" "row";
+  Hashtbl.add tbl "ul" "list";
+  tbl
+
+(** Map from HTML element name to multiple possible implicit roles.
+
+    Some elements like 'th' can have different implicit roles depending
+    on context (columnheader or rowheader). *)
+let elements_with_implicit_roles : (string, string array) Hashtbl.t =
+  let tbl = Hashtbl.create 4 in
+  Hashtbl.add tbl "th" [| "columnheader"; "rowheader" |];
+  tbl
+
+(** Map from input type to implicit ARIA role. *)
+let input_types_with_implicit_role : (string, string) Hashtbl.t =
+  let tbl = Hashtbl.create 8 in
+  Hashtbl.add tbl "button" "button";
+  Hashtbl.add tbl "checkbox" "checkbox";
+  Hashtbl.add tbl "image" "button";
+  Hashtbl.add tbl "number" "spinbutton";
+  Hashtbl.add tbl "radio" "radio";
+  Hashtbl.add tbl "range" "slider";
+  Hashtbl.add tbl "reset" "button";
+  Hashtbl.add tbl "submit" "button";
+  tbl
+
+(** Map from ARIA attribute to array of roles for which it is deprecated.
+
+    These attributes should not be used on elements with these roles. *)
+let aria_deprecated_attributes_by_role : (string, string array) Hashtbl.t =
+  let tbl = Hashtbl.create 8 in
+
+  (* aria-disabled deprecated for many roles *)
+  Hashtbl.add tbl "aria-disabled" [|
+    "alert"; "alertdialog"; "article"; "associationlist";
+    "associationlistitemkey"; "associationlistitemvalue"; "banner";
+    "blockquote"; "caption"; "cell"; "code"; "command"; "comment";
+    "complementary"; "contentinfo"; "definition"; "deletion";
+    "dialog"; "directory"; "document"; "emphasis"; "feed"; "figure";
+    "form"; "generic"; "heading"; "img"; "insertion"; "landmark";
+    "list"; "listitem"; "log"; "main"; "mark"; "marquee"; "math";
+    "meter"; "navigation"; "note"; "paragraph"; "presentation";
+    "progressbar"; "range"; "region"; "rowgroup"; "search";
+    "section"; "sectionhead"; "status"; "strong"; "structure";
+    "subscript"; "suggestion"; "superscript"; "table"; "tabpanel";
+    "term"; "time"; "timer"; "tooltip"; "widget"; "window"
+  |];
+
+  (* aria-errormessage deprecated for many roles *)
+  Hashtbl.add tbl "aria-errormessage" [|
+    "alert"; "alertdialog"; "article"; "associationlist";
+    "associationlistitemkey"; "associationlistitemvalue"; "banner";
+    "blockquote"; "button"; "caption"; "cell"; "code"; "command";
+    "comment"; "complementary"; "composite"; "contentinfo";
+    "definition"; "deletion"; "dialog"; "directory"; "document";
+    "emphasis"; "feed"; "figure"; "form"; "generic"; "grid"; "group";
+    "heading"; "img"; "input"; "insertion"; "landmark"; "link"; "list";
+    "listitem"; "log"; "main"; "mark"; "marquee"; "math"; "menu";
+    "menubar"; "menuitem"; "menuitemcheckbox"; "menuitemradio";
+    "meter"; "navigation"; "note"; "option"; "paragraph";
+    "presentation"; "progressbar"; "radio"; "range"; "region"; "row";
+    "rowgroup"; "scrollbar"; "search"; "section"; "sectionhead";
+    "select"; "separator"; "status"; "strong"; "structure";
+    "subscript"; "suggestion"; "superscript"; "tab"; "table";
+    "tablist"; "tabpanel"; "term"; "time"; "timer"; "toolbar";
+    "tooltip"; "treeitem"; "widget"; "window"
+  |];
+
+  (* aria-haspopup deprecated for many roles *)
+  Hashtbl.add tbl "aria-haspopup" [|
+    "alert"; "alertdialog"; "article"; "associationlist";
+    "associationlistitemkey"; "associationlistitemvalue"; "banner";
+    "blockquote"; "caption"; "cell"; "checkbox"; "code"; "command";
+    "comment"; "complementary"; "composite"; "contentinfo";
+    "definition"; "deletion"; "dialog"; "directory"; "document";
+    "emphasis"; "feed"; "figure"; "form"; "generic"; "grid"; "group";
+    "heading"; "img"; "input"; "insertion"; "landmark"; "list";
+    "listbox"; "listitem"; "log"; "main"; "mark"; "marquee"; "math";
+    "menu"; "menubar"; "meter"; "navigation"; "note"; "option";
+    "paragraph"; "presentation"; "progressbar"; "radio"; "radiogroup";
+    "range"; "region"; "row"; "rowgroup"; "scrollbar"; "search";
+    "section"; "sectionhead"; "select"; "separator"; "spinbutton";
+    "status"; "strong"; "structure"; "subscript"; "suggestion";
+    "superscript"; "switch"; "table"; "tablist"; "tabpanel"; "term";
+    "time"; "timer"; "toolbar"; "tooltip"; "tree"; "treegrid";
+    "widget"; "window"
+  |];
+
+  (* aria-invalid deprecated for many roles *)
+  Hashtbl.add tbl "aria-invalid" [|
+    "alert"; "alertdialog"; "article"; "associationlist";
+    "associationlistitemkey"; "associationlistitemvalue"; "banner";
+    "blockquote"; "button"; "caption"; "cell"; "code"; "command";
+    "comment"; "complementary"; "composite"; "contentinfo";
+    "definition"; "deletion"; "dialog"; "directory"; "document";
+    "emphasis"; "feed"; "figure"; "form"; "generic"; "grid"; "group";
+    "heading"; "img"; "input"; "insertion"; "landmark"; "link"; "list";
+    "listitem"; "log"; "main"; "mark"; "marquee"; "math"; "menu";
+    "menubar"; "menuitem"; "menuitemcheckbox"; "menuitemradio";
+    "meter"; "navigation"; "note"; "option"; "paragraph";
+    "presentation"; "progressbar"; "radio"; "range"; "region"; "row";
+    "rowgroup"; "scrollbar"; "search"; "section"; "sectionhead";
+    "select"; "separator"; "status"; "strong"; "structure";
+    "subscript"; "suggestion"; "superscript"; "tab"; "table";
+    "tablist"; "tabpanel"; "term"; "time"; "timer"; "toolbar";
+    "tooltip"; "treeitem"; "widget"; "window"
+  |];
+
+  (* aria-level deprecated for listitem *)
+  Hashtbl.add tbl "aria-level" [| "listitem" |];
+
+  tbl
+
+(** Split a role attribute value into individual roles.
+
+    The role attribute can contain multiple space-separated role tokens. *)
+let split_roles role_value =
+  let trimmed = String.trim role_value in
+  if trimmed = "" then []
+  else
+    String.split_on_char ' ' trimmed
+    |> List.filter (fun s -> String.trim s <> "")
+    |> List.map String.lowercase_ascii
+
+(** Get the implicit role for an HTML element. *)
+let get_implicit_role element_name attrs =
+  (* Check for input element with type attribute *)
+  if element_name = "input" then begin
+    match List.assoc_opt "type" attrs with
+    | Some input_type ->
+        let input_type = String.lowercase_ascii input_type in
+        Hashtbl.find_opt input_types_with_implicit_role input_type
+    | None -> Some "textbox" (* default input type is text *)
+  end
+  else
+    Hashtbl.find_opt elements_with_implicit_role element_name
+
+(** Get all possible implicit roles for an element (for elements like 'th').
+
+    Note: This function is not currently used but is provided for completeness. *)
+let _get_implicit_roles element_name =
+  match Hashtbl.find_opt elements_with_implicit_roles element_name with
+  | Some roles -> Array.to_list roles
+  | None ->
+      match get_implicit_role element_name [] with
+      | Some role -> [role]
+      | None -> []
+
+(** Stack node representing an element in the ancestor chain. *)
+type stack_node = {
+  explicit_roles : string list;
+  implicit_role : string option;
+}
+
+(** Checker state. *)
+type state = {
+  mutable stack : stack_node list;
+}
+
+let create () = { stack = [] }
+
+let reset state = state.stack <- []
+
+(** Check if any ancestor has one of the required roles. *)
+let has_required_ancestor_role state required_roles =
+  List.exists (fun ancestor ->
+    (* Check explicit roles *)
+    List.exists (fun role ->
+      List.mem role required_roles
+    ) ancestor.explicit_roles
+    ||
+    (* Check implicit role *)
+    match ancestor.implicit_role with
+    | Some implicit_role -> List.mem implicit_role required_roles
+    | None -> false
+  ) state.stack
+
+(** Render a list of roles as a human-readable string. *)
+let render_role_set roles =
+  match roles with
+  | [] -> ""
+  | [role] -> "\"" ^ role ^ "\""
+  | _ ->
+      let quoted = List.map (fun r -> "\"" ^ r ^ "\"") roles in
+      String.concat " or " quoted
+
+let start_element state ~name ~namespace ~attrs collector =
+  (* Only process HTML elements *)
+  match namespace with
+  | Some _ -> () (* Skip non-HTML elements *)
+  | None ->
+      let role_attr = List.assoc_opt "role" attrs in
+      let aria_label = List.assoc_opt "aria-label" attrs in
+      let aria_labelledby = List.assoc_opt "aria-labelledby" attrs in
+      let has_accessible_name =
+        (match aria_label with Some v -> String.trim v <> "" | None -> false) ||
+        (match aria_labelledby with Some v -> String.trim v <> "" | None -> false)
+      in
+
+      (* Parse explicit roles from role attribute *)
+      let explicit_roles = match role_attr with
+        | Some role_value -> split_roles role_value
+        | None -> []
+      in
+
+      (* Get implicit role for this element *)
+      let implicit_role = get_implicit_role name attrs in
+
+      (* Validate explicit roles *)
+      List.iter (fun role ->
+        (* Check if role is valid *)
+        if not (Hashtbl.mem valid_aria_roles role) then
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Invalid ARIA role \"%s\"." role) ();
+
+        (* Check if role cannot be named *)
+        if Hashtbl.mem roles_which_cannot_be_named role && has_accessible_name then
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf
+              "Elements with role=\"%s\" must not have accessible names (via aria-label or aria-labelledby)."
+              role) ();
+
+        (* Check for required ancestor roles *)
+        begin match Hashtbl.find_opt required_role_ancestor_by_descendant role with
+        | Some required_ancestors ->
+            if not (has_required_ancestor_role state required_ancestors) then
+              Message_collector.add_error collector
+                ~message:(Printf.sprintf
+                  "An element with \"role=%s\" must be contained in, or owned by, an element with the \"role\" value %s."
+                  role
+                  (render_role_set required_ancestors)) ()
+        | None -> ()
+        end;
+
+        (* Check for deprecated ARIA attributes for this role *)
+        List.iter (fun (attr_name, _attr_value) ->
+          if String.starts_with ~prefix:"aria-" attr_name then
+            match Hashtbl.find_opt aria_deprecated_attributes_by_role attr_name with
+            | Some deprecated_for_roles ->
+                (* Check if current role is in the deprecated list *)
+                if Array.mem role deprecated_for_roles then
+                  Message_collector.add_warning collector
+                    ~message:(Printf.sprintf
+                      "The \"%s\" attribute should not be used on any element which has \"role=%s\"."
+                      attr_name role) ()
+            | None -> ()
+        ) attrs
+      ) explicit_roles;
+
+      (* Push current element onto stack *)
+      let node = {
+        explicit_roles;
+        implicit_role;
+      } in
+      state.stack <- node :: state.stack
+
+let end_element state ~name:_ ~namespace _collector =
+  (* Only process HTML elements *)
+  match namespace with
+  | Some _ -> () (* Skip non-HTML elements *)
+  | None ->
+      (* Pop from stack *)
+      match state.stack with
+      | _ :: rest -> state.stack <- rest
+      | [] -> () (* Stack underflow - shouldn't happen in well-formed docs *)
+
+let characters _state _text _collector = ()
+
+let end_document _state _collector = ()
+
+let checker = (module struct
+  type nonrec state = state
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/specialized/aria_checker.mli

···
+(** ARIA (Accessible Rich Internet Applications) validation checker.
+
+    Validates ARIA roles, required ancestor roles, implicit roles, and
+    deprecated ARIA attributes according to the WAI-ARIA specification.
+
+    {2 Validation Rules}
+
+    The checker enforces the following ARIA validation rules:
+
+    {3 Valid ARIA Roles}
+
+    All valid WAI-ARIA 1.2 roles are recognized:
+
+    - {b Document structure roles}: article, definition, directory, document,
+      feed, figure, group, heading, img, list, listitem, math, none, note,
+      presentation, region, separator, table, term, toolbar, tooltip
+    - {b Widget roles}: button, checkbox, combobox, dialog, grid, gridcell,
+      link, listbox, menu, menubar, menuitem, menuitemcheckbox,
+      menuitemradio, option, progressbar, radio, radiogroup, scrollbar,
+      slider, spinbutton, switch, tab, tablist, tabpanel, textbox, tree,
+      treegrid, treeitem
+    - {b Landmark roles}: banner, complementary, contentinfo, form, main,
+      navigation, search
+    - {b Live region roles}: alert, log, marquee, status, timer
+    - {b Window roles}: alertdialog
+    - {b Abstract roles} (not for use in content): command, composite, input,
+      landmark, range, roletype, section, sectionhead, select, structure,
+      widget, window
+
+    {3 Required Ancestor Roles}
+
+    Certain ARIA roles require specific ancestor roles:
+
+    - [option] requires [listbox]
+    - [menuitem], [menuitemcheckbox], [menuitemradio] require [menu] or
+      [menubar]
+    - [tab] requires [tablist]
+    - [treeitem] requires [tree] or [group]
+    - [listitem] requires [list] or [group]
+    - [cell], [gridcell], [columnheader], [rowheader] require [row]
+    - [row] requires [grid], [rowgroup], [table], or [treegrid]
+    - [rowgroup] requires [grid], [table], or [treegrid]
+
+    {3 Roles That Cannot Be Named}
+
+    These roles must not have accessible names (via aria-label or
+    aria-labelledby):
+
+    - caption, code, deletion, emphasis, generic, insertion, paragraph,
+      presentation, strong, subscript, superscript
+
+    {3 Implicit ARIA Roles}
+
+    HTML elements have implicit ARIA roles:
+
+    - [<article>] has implicit role [article]
+    - [<aside>] has implicit role [complementary]
+    - [<button>] has implicit role [button]
+    - [<dialog>] has implicit role [dialog]
+    - [<footer>] has implicit role [contentinfo]
+    - [<header>] has implicit role [banner]
+    - [<main>] has implicit role [main]
+    - [<nav>] has implicit role [navigation]
+    - And many more...
+
+    {3 Deprecated ARIA Attributes}
+
+    Certain ARIA attributes are deprecated for specific roles:
+
+    - [aria-disabled] is deprecated for: alert, article, banner, cell,
+      document, feed, figure, heading, img, list, listitem, main, navigation,
+      region, and many others
+    - [aria-errormessage] is deprecated for: alert, article, banner, button,
+      cell, document, link, and many others
+    - [aria-haspopup] is deprecated for: alert, article, checkbox, listbox,
+      and many others
+    - [aria-invalid] is deprecated for: alert, article, button, cell,
+      document, link, and many others
+    - [aria-level] is deprecated for: listitem
+
+    {2 Implementation Details}
+
+    The checker maintains a stack of ancestor elements with their roles
+    (explicit and implicit) to validate required ancestor relationships.
+    When an element with a role attribute is encountered, the checker:
+
+    1. Parses the role attribute value (space-separated tokens)
+    2. Validates each role against the list of valid roles
+    3. Checks if the role requires an ancestor role
+    4. Verifies the required ancestor is present in the ancestor stack
+    5. Checks for deprecated ARIA attributes on elements with specific roles
+    6. Validates that roles which cannot be named do not have aria-label or
+       aria-labelledby attributes
+
+    @see <https://www.w3.org/TR/wai-aria-1.2/>
+         WAI-ARIA 1.2 specification
+*)
+
+include Checker.S
+
+val checker : Checker.t
+(** [checker] is a checker instance for validating ARIA roles and attributes. *)

lib/html5_checker/specialized/heading_checker.ml

···
+(** Heading structure validation checker.
+
+    This checker validates that:
+    - Heading levels don't skip (e.g., h1 to h3)
+    - Documents have at least one heading
+    - Multiple h1 usage is noted
+    - Headings are not empty *)
+
+(** Checker state tracking heading structure. *)
+type state = {
+  mutable current_level : int option;
+  mutable h1_count : int;
+  mutable has_any_heading : bool;
+  mutable first_heading_checked : bool;
+  mutable in_heading : string option;
+  mutable heading_has_text : bool;
+}
+
+let create () =
+  {
+    current_level = None;
+    h1_count = 0;
+    has_any_heading = false;
+    first_heading_checked = false;
+    in_heading = None;
+    heading_has_text = false;
+  }
+
+let reset state =
+  state.current_level <- None;
+  state.h1_count <- 0;
+  state.has_any_heading <- false;
+  state.first_heading_checked <- false;
+  state.in_heading <- None;
+  state.heading_has_text <- false
+
+(** Extract heading level from tag name (e.g., "h1" -> 1). *)
+let heading_level name =
+  match String.lowercase_ascii name with
+  | "h1" -> Some 1
+  | "h2" -> Some 2
+  | "h3" -> Some 3
+  | "h4" -> Some 4
+  | "h5" -> Some 5
+  | "h6" -> Some 6
+  | _ -> None
+
+(** Check if text is effectively empty (only whitespace). *)
+let is_empty_text text =
+  let rec check i =
+    if i >= String.length text then
+      true
+    else
+      match text.[i] with
+      | ' ' | '\t' | '\n' | '\r' -> check (i + 1)
+      | _ -> false
+  in
+  check 0
+
+let start_element state ~name ~namespace:_ ~attrs:_ collector =
+  match heading_level name with
+  | Some level ->
+      state.has_any_heading <- true;
+
+      (* Check if this is the first heading *)
+      if not state.first_heading_checked then begin
+        state.first_heading_checked <- true;
+        if level <> 1 then
+          Message_collector.add_warning collector
+            ~message:(Printf.sprintf
+              "First heading in document is <%s>, should typically be <h1>"
+              name)
+            ~code:"first-heading-not-h1"
+            ~element:name
+            ()
+      end;
+
+      (* Track h1 count *)
+      if level = 1 then begin
+        state.h1_count <- state.h1_count + 1;
+        if state.h1_count > 1 then
+          Message_collector.add_warning collector
+            ~message:"Multiple <h1> elements detected. While valid in HTML5 sectioning content, traditional advice suggests one <h1> per page"
+            ~code:"multiple-h1"
+            ~element:name
+            ()
+      end;
+
+      (* Check for skipped levels *)
+      begin match state.current_level with
+      | None ->
+          state.current_level <- Some level
+      | Some prev_level ->
+          let diff = level - prev_level in
+          if diff > 1 then
+            Message_collector.add_warning collector
+              ~message:(Printf.sprintf
+                "Heading level skipped: <%s> follows <h%d>, skipping %d level%s. This can confuse screen reader users"
+                name prev_level (diff - 1) (if diff > 2 then "s" else ""))
+              ~code:"heading-level-skipped"
+              ~element:name
+              ();
+          state.current_level <- Some level
+      end;
+
+      (* Track that we're in a heading to check for empty content *)
+      state.in_heading <- Some name;
+      state.heading_has_text <- false
+
+  | None ->
+      (* Not a heading element *)
+      ()
+
+let end_element state ~name ~namespace:_ collector =
+  match state.in_heading with
+  | Some heading when heading = name ->
+      (* Exiting the heading we're tracking *)
+      if not state.heading_has_text then
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf
+            "Heading <%s> is empty or contains only whitespace. Empty headings are problematic for screen readers"
+            name)
+          ~code:"empty-heading"
+          ~element:name
+          ();
+      state.in_heading <- None;
+      state.heading_has_text <- false
+  | _ ->
+      ()
+
+let characters state text _collector =
+  (* If we're inside a heading, check if this text is non-whitespace *)
+  match state.in_heading with
+  | Some _ ->
+      if not (is_empty_text text) then
+        state.heading_has_text <- true
+  | None ->
+      ()
+
+let end_document state collector =
+  (* Check if document has any headings *)
+  if not state.has_any_heading then
+    Message_collector.add_warning collector
+      ~message:"Document contains no heading elements (h1-h6). Headings provide important document structure for accessibility"
+      ~code:"no-headings"
+      ()
+
+let checker = (module struct
+  type nonrec state = state
+
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/specialized/heading_checker.mli

···
+(** Heading structure validation checker.
+
+    Validates:
+    - Proper heading level hierarchy (no skipped levels)
+    - Document should have at least one heading
+    - Multiple h1 usage patterns
+    - Headings should not be empty *)
+
+include Checker.S
+
+val checker : Checker.t
+(** [checker] is a checker instance for validating heading structure. *)

lib/html5_checker/specialized/language_checker.ml

···
+(** Language attribute validation checker.
+
+    Validates language attributes. *)
+
+(** Checker state tracking language attributes. *)
+type state = {
+  mutable html_element_seen : bool;
+  mutable html_has_lang : bool;
+}
+
+let create () =
+  {
+    html_element_seen = false;
+    html_has_lang = false;
+  }
+
+let reset state =
+  state.html_element_seen <- false;
+  state.html_has_lang <- false
+
+(** Get attribute value from attribute list. *)
+let get_attr attrs name =
+  try Some (List.assoc name attrs)
+  with Not_found -> None
+
+(** Validate language attribute. *)
+let validate_lang_attr value ~location ~element collector =
+  match Dt_language.Language_or_empty.validate value with
+  | Ok () -> ()
+  | Error msg ->
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf "Invalid lang attribute: %s" msg)
+        ~code:"invalid-lang"
+        ?location
+        ~element
+        ~attribute:"lang"
+        ()
+
+(** Check if lang and xml:lang match. *)
+let check_lang_xmllang_match ~lang ~xmllang ~location ~element collector =
+  if lang <> xmllang then
+    Message_collector.add_warning collector
+      ~message:(Printf.sprintf
+        "lang attribute '%s' does not match xml:lang attribute '%s'" lang xmllang)
+      ~code:"lang-xmllang-mismatch"
+      ?location
+      ~element
+      ()
+
+(** Process language attributes. *)
+let process_language_attrs state ~element ~namespace ~attrs ~location collector =
+  let lang_opt = get_attr attrs "lang" in
+  let xmllang_opt = get_attr attrs "xml:lang" in
+
+  (* Check if this is the html element *)
+  if element = "html" && namespace = None then begin
+    state.html_element_seen <- true;
+    state.html_has_lang <- lang_opt <> None
+  end;
+
+  (* Validate lang attribute *)
+  begin match lang_opt with
+  | Some lang ->
+      validate_lang_attr lang ~location ~element collector
+  | None -> ()
+  end;
+
+  (* Validate xml:lang attribute *)
+  begin match xmllang_opt with
+  | Some xmllang ->
+      validate_lang_attr xmllang ~location ~element collector
+  | None -> ()
+  end;
+
+  (* Check that lang and xml:lang match if both present *)
+  begin match lang_opt, xmllang_opt with
+  | Some lang, Some xmllang ->
+      check_lang_xmllang_match ~lang ~xmllang ~location ~element collector
+  | _ -> ()
+  end
+
+let start_element state ~name ~namespace ~attrs collector =
+  let location = None in
+  process_language_attrs state ~element:name ~namespace ~attrs ~location collector
+
+let end_element _state ~name:_ ~namespace:_ _collector =
+  ()
+
+let characters _state _text _collector =
+  ()
+
+let end_document state collector =
+  (* Warn if html element lacks lang attribute *)
+  if state.html_element_seen && not state.html_has_lang then
+    Message_collector.add_warning collector
+      ~message:"The <html> element should have a lang attribute to specify \
+               the document's primary language"
+      ~code:"missing-lang-on-html"
+      ~element:"html"
+      ()
+
+let checker = (module struct
+  type nonrec state = state
+
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/specialized/language_checker.mli

···
+(** Language attribute validation checker.
+
+    Validates:
+    - lang attribute values are valid BCP 47 tags
+    - xml:lang matches lang when both present
+    - Document has a lang attribute on root element
+
+    This checker ensures proper language markup:
+    - lang attribute values are validated using BCP 47 format
+    - When both lang and xml:lang are present, they must match
+    - Warning if <html> element lacks lang attribute
+    - Empty lang="" is valid (indicates unknown language)
+    - Primary language subtag should be valid *)
+
+include Checker.S
+
+val checker : Checker.t
+(** [checker] is a checker instance for validating language attributes. *)

lib/html5_checker/specialized/microdata_checker.ml

···
+(** Microdata validation checker.
+
+    Validates HTML5 microdata attributes. *)
+
+(** Information about an itemscope. *)
+type item_scope = {
+  element : string;
+  location : Message.location option; [@warning "-69"]
+  itemtype : string option; [@warning "-69"]
+  itemid : string option; [@warning "-69"]
+  itemref : string list; [@warning "-69"]
+}
+
+(** Information about an itemref reference. *)
+type itemref_reference = {
+  referring_element : string;
+  referenced_ids : string list;
+  location : Message.location option;
+}
+
+(** Checker state tracking microdata. *)
+type state = {
+  mutable scope_stack : item_scope list;
+  mutable itemref_references : itemref_reference list;
+  mutable all_ids : (string, unit) Hashtbl.t; [@warning "-69"]
+  mutable html_element_seen : bool; [@warning "-69"]
+}
+
+let create () =
+  {
+    scope_stack = [];
+    itemref_references = [];
+    all_ids = Hashtbl.create 64;
+    html_element_seen = false;
+  }
+
+let reset state =
+  state.scope_stack <- [];
+  state.itemref_references <- [];
+  Hashtbl.clear state.all_ids;
+  state.html_element_seen <- false
+
+(** Split whitespace-separated values. *)
+let split_whitespace value =
+  let rec split acc start i =
+    if i >= String.length value then
+      if i > start then
+        (String.sub value start (i - start)) :: acc
+      else
+        acc
+    else
+      match value.[i] with
+      | ' ' | '\t' | '\n' | '\r' ->
+          let acc' =
+            if i > start then
+              (String.sub value start (i - start)) :: acc
+            else
+              acc
+          in
+          split acc' (i + 1) (i + 1)
+      | _ ->
+          split acc start (i + 1)
+  in
+  List.rev (split [] 0 0)
+
+(** Check if a string is a valid URL (contains a colon). *)
+let is_url s =
+  String.contains s ':'
+
+(** Check if itemprop value is valid. *)
+let validate_itemprop_value value =
+  if String.length value = 0 then
+    Error "itemprop value must not be empty"
+  else if not (is_url value) && String.contains value ':' then
+    Error (Printf.sprintf
+      "itemprop value '%s' contains a colon but is not a URL" value)
+  else
+    Ok ()
+
+(** Check if element is inside an itemscope or referenced by itemref. *)
+let is_property_element state =
+  state.scope_stack <> []
+
+(** Get attributes from attribute list. *)
+let get_attr attrs name =
+  try Some (List.assoc name attrs)
+  with Not_found -> None
+
+(** Process microdata attributes. *)
+let process_microdata_attrs state ~element ~attrs ~location collector =
+  let has_itemscope = List.mem_assoc "itemscope" attrs in
+  let itemtype_opt = get_attr attrs "itemtype" in
+  let itemid_opt = get_attr attrs "itemid" in
+  let itemref_opt = get_attr attrs "itemref" in
+  let itemprop_opt = get_attr attrs "itemprop" in
+
+  (* Check itemid requires itemscope and itemtype *)
+  begin match itemid_opt with
+  | Some _itemid ->
+      if not has_itemscope then
+        Message_collector.add_error collector
+          ~message:"itemid attribute requires itemscope attribute"
+          ~code:"microdata-itemid-without-itemscope"
+          ?location
+          ~element
+          ~attribute:"itemid"
+          ();
+      if itemtype_opt = None then
+        Message_collector.add_error collector
+          ~message:"itemid attribute requires itemtype attribute"
+          ~code:"microdata-itemid-without-itemtype"
+          ?location
+          ~element
+          ~attribute:"itemid"
+          ()
+  | None -> ()
+  end;
+
+  (* Check itemref requires itemscope *)
+  begin match itemref_opt with
+  | Some itemref_value ->
+      if not has_itemscope then
+        Message_collector.add_error collector
+          ~message:"itemref attribute requires itemscope attribute"
+          ~code:"microdata-itemref-without-itemscope"
+          ?location
+          ~element
+          ~attribute:"itemref"
+          ()
+      else begin
+        (* Collect itemref references for later validation *)
+        let ids = split_whitespace itemref_value in
+        state.itemref_references <- {
+          referring_element = element;
+          referenced_ids = ids;
+          location;
+        } :: state.itemref_references
+      end
+  | None -> ()
+  end;
+
+  (* Check itemtype requires itemscope *)
+  begin match itemtype_opt with
+  | Some _itemtype ->
+      if not has_itemscope then
+        Message_collector.add_error collector
+          ~message:"itemtype attribute requires itemscope attribute"
+          ~code:"microdata-itemtype-without-itemscope"
+          ?location
+          ~element
+          ~attribute:"itemtype"
+          ()
+  | None -> ()
+  end;
+
+  (* Check itemprop value validity *)
+  begin match itemprop_opt with
+  | Some itemprop_value ->
+      let props = split_whitespace itemprop_value in
+      List.iter (fun prop ->
+        match validate_itemprop_value prop with
+        | Ok () -> ()
+        | Error msg ->
+            Message_collector.add_error collector
+              ~message:msg
+              ~code:"microdata-invalid-itemprop"
+              ?location
+              ~element
+              ~attribute:"itemprop"
+              ()
+      ) props;
+
+      (* Check itemprop can only appear on property elements *)
+      if not (is_property_element state) then
+        Message_collector.add_error collector
+          ~message:"itemprop attribute can only appear on elements that are \
+                   properties of an item (descendant of itemscope or referenced by itemref)"
+          ~code:"microdata-itemprop-outside-scope"
+          ?location
+          ~element
+          ~attribute:"itemprop"
+          ()
+  | None -> ()
+  end;
+
+  (* If this element has itemscope, push it onto the stack *)
+  if has_itemscope then begin
+    let itemref = match itemref_opt with
+      | Some v -> split_whitespace v
+      | None -> []
+    in
+    let scope = {
+      element;
+      location;
+      itemtype = itemtype_opt;
+      itemid = itemid_opt;
+      itemref;
+    } in
+    state.scope_stack <- scope :: state.scope_stack
+  end
+
+(** Track IDs for itemref validation. *)
+let track_id state attrs =
+  match get_attr attrs "id" with
+  | Some id ->
+      if String.length id > 0 then
+        Hashtbl.replace state.all_ids id ()
+  | None -> ()
+
+(** Detect itemref cycles using depth-first search. *)
+let detect_itemref_cycles state collector =
+  (* Build adjacency list from itemref references *)
+  let graph = Hashtbl.create 32 in
+  List.iter (fun ref ->
+    Hashtbl.replace graph ref.referring_element ref.referenced_ids
+  ) state.itemref_references;
+
+  (* DFS to detect cycles *)
+  let rec visit visited stack node =
+    if List.mem node stack then
+      (* Found a cycle *)
+      Some (node :: stack)
+    else if List.mem node visited then
+      None
+    else
+      match Hashtbl.find_opt graph node with
+      | None -> None
+      | Some neighbors ->
+          let stack' = node :: stack in
+          let rec check_neighbors = function
+            | [] -> None
+            | neighbor :: rest ->
+                match visit visited stack' neighbor with
+                | Some cycle -> Some cycle
+                | None -> check_neighbors rest
+          in
+          check_neighbors neighbors
+  in
+
+  (* Check all nodes *)
+  let rec check_all_nodes visited nodes =
+    match nodes with
+    | [] -> ()
+    | node :: rest ->
+        begin match visit visited [] node with
+        | Some cycle ->
+            let cycle_str = String.concat " -> " (List.rev cycle) in
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "itemref cycle detected: %s" cycle_str)
+              ~code:"microdata-itemref-cycle"
+              ()
+        | None -> ()
+        end;
+        check_all_nodes (node :: visited) rest
+  in
+
+  let all_nodes = Hashtbl.to_seq_keys graph |> List.of_seq in
+  check_all_nodes [] all_nodes
+
+let start_element state ~name ~namespace:_ ~attrs collector =
+  let location = None in
+  track_id state attrs;
+  process_microdata_attrs state ~element:name ~attrs ~location collector
+
+let end_element state ~name ~namespace:_ _collector =
+  (* Pop itemscope from stack if this element had one *)
+  match state.scope_stack with
+  | scope :: rest when scope.element = name ->
+      state.scope_stack <- rest
+  | _ -> ()
+
+let characters _state _text _collector =
+  ()
+
+let end_document state collector =
+  (* Check all itemref references point to existing IDs *)
+  List.iter (fun ref ->
+    List.iter (fun id ->
+      if not (Hashtbl.mem state.all_ids id) then
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf
+            "itemref on <%s> refers to ID '%s' which does not exist"
+            ref.referring_element id)
+          ~code:"microdata-itemref-dangling"
+          ?location:ref.location
+          ~element:ref.referring_element
+          ~attribute:"itemref"
+          ()
+    ) ref.referenced_ids
+  ) state.itemref_references;
+
+  (* Detect itemref cycles *)
+  detect_itemref_cycles state collector
+
+let checker = (module struct
+  type nonrec state = state
+
+  let create = create
+  let reset = reset
+  let start_element = start_element
+  let end_element = end_element
+  let characters = characters
+  let end_document = end_document
+end : Checker.S)

lib/html5_checker/specialized/microdata_checker.mli

···
+(** Microdata validation checker.
+
+    Validates HTML5 microdata (itemscope, itemtype, itemprop, itemid, itemref).
+
+    This checker verifies that microdata attributes are used correctly:
+    - itemprop can only appear on elements that are properties of an item
+      (descendant of itemscope or referenced by itemref)
+    - itemid requires both itemscope and itemtype
+    - itemref requires itemscope
+    - itemtype requires itemscope
+    - itemref values must reference existing IDs
+    - Detects itemref cycles (A references B, B references A)
+    - itemprop values must be valid property names (no colons unless URL) *)
+
+include Checker.S
+
+val checker : Checker.t
+(** [checker] is a checker instance for validating microdata. *)

lib/html5_checker/specialized/table_checker.ml

···
+(** Table structure validation checker implementation.
+
+    This module implements comprehensive table structure validation including
+    cell overlap detection, span validation, and structural integrity checks. *)
+
+(** HTML namespace constant *)
+let html_ns = "http://www.w3.org/1999/xhtml"
+
+(** Maximum allowed colspan value per HTML5 spec *)
+let max_colspan = 1000
+
+(** Maximum allowed rowspan value per HTML5 spec *)
+let max_rowspan = 65534
+
+(** Special rowspan value meaning "span to end of row group" *)
+let rowspan_zero_magic = max_rowspan
+
+(** {1 Cell Representation} *)
+
+(** A table cell with positioning information *)
+type cell = {
+  mutable left : int;
+  (** Column in which this cell starts (zero-indexed) *)
+  mutable right : int;
+  (** First column into which this cell does not span *)
+  mutable bottom : int;
+  (** First row onto which this cell does not span (or rowspan_zero_magic) *)
+  headers : string list;
+  (** IDs referenced by the headers attribute *)
+  is_header : bool;
+  (** Whether this is a th element *)
+  element_name : string;
+  (** "td" or "th" *)
+}
+
+(** Create a cell from colspan and rowspan values *)
+let make_cell ~colspan ~rowspan ~headers ~is_header collector =
+  let colspan =
+    if colspan > max_colspan then (
+      Message_collector.add_error collector
+        ~message:
+          (Printf.sprintf
+             {|The value of the "colspan" attribute must be less than or equal to %d.|}
+             max_colspan)
+        ();
+      max_colspan)
+    else colspan
+  in
+  let rowspan =
+    if rowspan > max_rowspan then (
+      Message_collector.add_error collector
+        ~message:
+          (Printf.sprintf
+             {|The value of the "rowspan" attribute must be less than or equal to %d.|}
+             max_rowspan)
+        ();
+      max_rowspan)
+    else rowspan
+  in
+  {
+    left = 0;
+    right = colspan;
+    bottom = (if rowspan = 0 then rowspan_zero_magic else rowspan);
+    headers;
+    is_header;
+    element_name = (if is_header then "th" else "td");
+  }
+
+(** Set the absolute position of a cell *)
+let set_cell_position cell ~row ~col =
+  cell.left <- col;
+  cell.right <- cell.right + col;
+  if cell.bottom <> rowspan_zero_magic then cell.bottom <- cell.bottom + row
+
+(** Check if a cell should be removed from the active set *)
+let should_cull_cell cell ~row = row >= cell.bottom
+
+(** Check if two cells overlap horizontally *)
+let cells_overlap_horizontally cell1 cell2 =
+  not (cell2.right <= cell1.left || cell1.right <= cell2.left)
+
+(** Emit error for horizontal cell overlap *)
+let err_on_horizontal_overlap cell1 cell2 collector =
+  if cells_overlap_horizontally cell1 cell2 then (
+    Message_collector.add_error collector
+      ~message:"Table cell is overlapped by later table cell." ();
+    Message_collector.add_error collector
+      ~message:"Table cell overlaps an earlier table cell." ())
+
+(** Check if cell spans past end of row group *)
+let err_if_not_rowspan_zero cell ~row_group_type collector =
+  if cell.bottom <> rowspan_zero_magic then
+    let group_desc =
+      match row_group_type with
+      | None -> "implicit row group"
+      | Some t -> Printf.sprintf {|row group established by a "%s" element|} t
+    in
+    Message_collector.add_error collector
+      ~message:
+        (Printf.sprintf
+           "Table cell spans past the end of its %s; clipped to the end of \
+            the row group."
+           group_desc)
+      ()
+
+(** {1 Column Range Tracking} *)
+
+(** A contiguous range of columns without cells *)
+type column_range = {
+  element : string;
+  (** Element that established this range (col/colgroup/td/th) *)
+  mutable left : int;
+  (** Leftmost column in range *)
+  mutable right : int;
+  (** First column to right not in range *)
+  mutable next : column_range option;
+      (** Next range in linked list *)
+}
+
+(** Create a column range *)
+let make_column_range ~element ~left ~right =
+  { element; left; right; next = None }
+
+(** Check if column range contains a single column *)
+let is_single_col range = range.left + 1 = range.right
+
+(** Test if a column hits a range (-1=left, 0=in, 1=right) *)
+let hits_column range column =
+  if column < range.left then -1
+  else if column >= range.right then 1
+  else 0
+
+(** Remove a column from a range, returning the new range(s) *)
+let remove_column range column =
+  if is_single_col range then None
+  else if column = range.left then (
+    range.left <- range.left + 1;
+    Some range)
+  else if column + 1 = range.right then (
+    range.right <- range.right - 1;
+    Some range)
+  else
+    (* Split into two ranges *)
+    let created = make_column_range ~element:range.element ~left:(column + 1) ~right:range.right in
+    created.next <- range.next;
+    range.next <- Some created;
+    range.right <- column;
+    Some created
+
+(** {1 Row Group State} *)
+
+(** State for a row group (explicit or implicit) *)
+type row_group = {
+  mutable current_row : int;
+  (** Current row index within this group *)
+  mutable insertion_point : int;
+  (** Column position for next cell insertion *)
+  mutable next_old_cell : int;
+  (** Index into cells_on_current_row *)
+  mutable row_had_cells : bool;
+  (** Whether current row has any cells *)
+  cells_in_effect : ((int * int), cell) Hashtbl.t;
+  (** Cells from previous rows still spanning down, keyed by (bottom, left) *)
+  mutable cells_on_current_row : cell array;
+  (** Cells from previous rows affecting current row, sorted by left *)
+  row_group_type : string option;
+      (** Name of row group element (thead/tbody/tfoot) or None for implicit *)
+}
+
+(** Create a new row group *)
+let make_row_group ~row_group_type =
+  {
+    current_row = -1;
+    insertion_point = 0;
+    next_old_cell = 0;
+    row_had_cells = false;
+    cells_in_effect = Hashtbl.create 16;
+    cells_on_current_row = [||];
+    row_group_type;
+  }
+
+(** Start a new row in the row group *)
+let start_row_in_group group =
+  group.current_row <- group.current_row + 1;
+  group.insertion_point <- 0;
+  group.next_old_cell <- 0;
+  group.row_had_cells <- false;
+  (* Collect cells still in effect and sort by left column *)
+  let active_cells : cell list =
+    Hashtbl.fold
+      (fun _ (cell : cell) acc -> if not (should_cull_cell cell ~row:group.current_row) then cell :: acc else acc)
+      group.cells_in_effect []
+  in
+  let sorted = List.sort (fun (c1 : cell) (c2 : cell) -> Int.compare c1.left c2.left) active_cells in
+  group.cells_on_current_row <- Array.of_list sorted
+
+(** Find the next available insertion point *)
+let rec find_insertion_point group =
+  if group.next_old_cell < Array.length group.cells_on_current_row then
+    let other = group.cells_on_current_row.(group.next_old_cell) in
+    if group.insertion_point < other.left then ()
+    else (
+      let right = other.right in
+      if right > group.insertion_point then group.insertion_point <- right;
+      group.next_old_cell <- group.next_old_cell + 1;
+      find_insertion_point group)
+
+(** Add a cell to the row group *)
+let add_cell_to_group group cell collector =
+  group.row_had_cells <- true;
+  find_insertion_point group;
+  set_cell_position cell ~row:group.current_row ~col:group.insertion_point;
+
+  (* Check for overlaps with cells from previous rows *)
+  for i = group.next_old_cell to Array.length group.cells_on_current_row - 1 do
+    err_on_horizontal_overlap group.cells_on_current_row.(i) cell collector
+  done;
+
+  (* Add to cells in effect if it spans beyond current row *)
+  if cell.bottom > group.current_row + 1 then
+    Hashtbl.add group.cells_in_effect (cell.bottom, cell.left) cell;
+
+  group.insertion_point <- cell.right
+
+(** End the current row *)
+let end_row_in_group group collector =
+  (if not group.row_had_cells then
+    let group_desc =
+      match group.row_group_type with
+      | None -> "an implicit row group"
+      | Some t -> Printf.sprintf {|a row group established by a "%s" element|} t
+    in
+    Message_collector.add_error collector
+      ~message:
+        (Printf.sprintf {|Row %d of %s has no cells beginning on it.|}
+           (group.current_row + 1) group_desc)
+      ());
+
+  find_insertion_point group;
+  group.cells_on_current_row <- [||];
+
+  (* Cull cells that don't span to next row *)
+  let to_remove = ref [] in
+  Hashtbl.iter
+    (fun key cell ->
+      if should_cull_cell cell ~row:(group.current_row + 1) then to_remove := key :: !to_remove)
+    group.cells_in_effect;
+  List.iter (Hashtbl.remove group.cells_in_effect) !to_remove;
+
+  (* Return the final insertion point (row width) *)
+  group.insertion_point
+
+(** End the row group *)
+let end_row_group group collector =
+  Hashtbl.iter
+    (fun _ cell -> err_if_not_rowspan_zero cell ~row_group_type:group.row_group_type collector)
+    group.cells_in_effect
+
+(** {1 Table State} *)
+
+(** Parser state within a table *)
+type table_state =
+  | InTableAtStart
+  | InTableAtPotentialRowGroupStart
+  | InColgroup
+  | InColInColgroup
+  | InColInImplicitGroup
+  | InRowGroup
+  | InRowInRowGroup
+  | InCellInRowGroup
+  | InRowInImplicitRowGroup
+  | InImplicitRowGroup
+  | InCellInImplicitRowGroup
+  | InTableColsSeen
+
+(** State for a single table *)
+type table = {
+  mutable state : table_state;
+  mutable suppressed_starts : int;
+  (** Count of nested suppressed elements *)
+  mutable hard_width : bool;
+  (** Whether column count was set by col/colgroup *)
+  mutable column_count : int;
+  (** Established column count (-1 if not set) *)
+  mutable real_column_count : int;
+  (** Actual maximum column count seen *)
+  mutable pending_colgroup_span : int;
+  (** Span for colgroup without col children *)
+  header_ids : (string, unit) Hashtbl.t;
+  (** IDs of th elements *)
+  cells_with_headers : cell list ref;
+  (** Cells with headers attribute *)
+  mutable current_row_group : row_group option;
+  (** Current row group *)
+  mutable first_col_range : column_range option;
+  (** Head of column range list *)
+  mutable last_col_range : column_range option;
+  (** Tail of column range list *)
+  mutable current_col_range : column_range option;
+  (** Current range being inspected *)
+  mutable previous_col_range : column_range option;
+      (** Previous range inspected *)
+}
+
+(** Create a new table *)
+let make_table () =
+  {
+    state = InTableAtStart;
+    suppressed_starts = 0;
+    hard_width = false;
+    column_count = -1;
+    real_column_count = 0;
+    pending_colgroup_span = 0;
+    header_ids = Hashtbl.create 16;
+    cells_with_headers = ref [];
+    current_row_group = None;
+    first_col_range = None;
+    last_col_range = None;
+    current_col_range = None;
+    previous_col_range = None;
+  }
+
+(** Append a column range to the list *)
+let append_column_range table range =
+  match table.last_col_range with
+  | None ->
+      table.first_col_range <- Some range;
+      table.last_col_range <- Some range
+  | Some last ->
+      last.next <- Some range;
+      table.last_col_range <- Some range
+
+(** Report a cell back to table for column tracking *)
+let report_cell_to_table table (cell : cell) =
+  let left = cell.left in
+  let right = cell.right in
+
+  (* Check if cell extends past known columns *)
+  if right > table.real_column_count then (
+    if left = table.real_column_count then (
+      (* Entirely past existing columns *)
+      if left + 1 <> right then
+        append_column_range table
+          (make_column_range ~element:cell.element_name ~left:(left + 1) ~right);
+      table.real_column_count <- right)
+    else (
+      (* Partially past existing columns *)
+      append_column_range table
+        (make_column_range ~element:cell.element_name ~left:table.real_column_count ~right);
+      table.real_column_count <- right));
+
+  (* Track column usage *)
+  let rec process_ranges () =
+    match table.current_col_range with
+    | None -> ()
+    | Some range ->
+        let hit = hits_column range left in
+        if hit = 0 then (
+          (* Column hits this range - remove it *)
+          match remove_column range left with
+          | None ->
+              (* Range destroyed *)
+              if Option.is_some table.previous_col_range then
+                (Option.get table.previous_col_range).next <- range.next;
+              if table.first_col_range = Some range then table.first_col_range <- range.next;
+              if table.last_col_range = Some range then table.last_col_range <- table.previous_col_range;
+              table.current_col_range <- range.next
+          | Some new_range ->
+              if table.last_col_range = Some range then table.last_col_range <- Some new_range;
+              table.current_col_range <- Some new_range)
+        else if hit = -1 then
+          ()
+        else (
+          (* hit = 1, try next range *)
+          table.previous_col_range <- Some range;
+          table.current_col_range <- range.next;
+          process_ranges ())
+  in
+  process_ranges ()
+
+(** {1 Attribute Parsing} *)
+
+(** Parse a non-negative integer attribute, returning 1 if absent or invalid *)
+let parse_non_negative_int attrs name =
+  match List.assoc_opt name attrs with
+  | None -> 1
+  | Some v -> (
+      try
+        let n = int_of_string v in
+        if n >= 0 then n else 1
+      with Failure _ -> 1)
+
+(** Parse a positive integer attribute, returning 1 if absent or invalid *)
+let parse_positive_int attrs name =
+  match List.assoc_opt name attrs with
+  | None -> 1
+  | Some v -> (
+      try
+        let n = int_of_string v in
+        if n > 0 then n else 1
+      with Failure _ -> 1)
+
+(** Parse the headers attribute into a list of IDs *)
+let parse_headers attrs =
+  match List.assoc_opt "headers" attrs with
+  | None -> []
+  | Some v ->
+      let parts = String.split_on_char ' ' v in
+      List.filter (fun s -> String.length s > 0) parts
+
+(** Parse span attribute, clamping to max_colspan *)
+let parse_span attrs collector =
+  let span = parse_non_negative_int attrs "span" in
+  if span > max_colspan then (
+    Message_collector.add_error collector
+      ~message:
+        (Printf.sprintf {|The value of the "span" attribute must be less than or equal to %d.|}
+           max_colspan)
+      ();
+    max_colspan)
+  else span
+
+(** {1 Table Event Handlers} *)
+
+(** Check if we should suppress the start event *)
+let need_suppress_start table =
+  if table.suppressed_starts > 0 then (
+    table.suppressed_starts <- table.suppressed_starts + 1;
+    true)
+  else false
+
+(** Check if we should suppress the end event *)
+let need_suppress_end table =
+  if table.suppressed_starts > 0 then (
+    table.suppressed_starts <- table.suppressed_starts - 1;
+    true)
+  else false
+
+(** Start a row group *)
+let start_row_group table local_name collector =
+  if need_suppress_start table then ()
+  else
+    match table.state with
+    | InImplicitRowGroup -> (
+        match table.current_row_group with
+        | Some group ->
+            end_row_group group collector;
+            table.current_row_group <- Some (make_row_group ~row_group_type:(Some local_name));
+            table.state <- InRowGroup
+        | None -> failwith "Bug: InImplicitRowGroup but no current row group")
+    | InTableAtStart | InTableColsSeen | InTableAtPotentialRowGroupStart ->
+        table.current_row_group <- Some (make_row_group ~row_group_type:(Some local_name));
+        table.state <- InRowGroup
+    | _ -> table.suppressed_starts <- 1
+
+(** End a row group *)
+let end_row_group_handler table collector =
+  if need_suppress_end table then ()
+  else
+    match table.state with
+    | InRowGroup -> (
+        match table.current_row_group with
+        | Some group ->
+            end_row_group group collector;
+            table.current_row_group <- None;
+            table.state <- InTableAtPotentialRowGroupStart
+        | None -> failwith "Bug: InRowGroup but no current row group")
+    | _ -> failwith "Bug: end_row_group in wrong state"
+
+(** Start a row *)
+let start_row table collector =
+  if need_suppress_start table then ()
+  else
+    match table.state with
+    | InTableAtStart | InTableColsSeen | InTableAtPotentialRowGroupStart ->
+        table.current_row_group <- Some (make_row_group ~row_group_type:None);
+        table.state <- InRowInImplicitRowGroup;
+        table.current_col_range <- table.first_col_range;
+        table.previous_col_range <- None;
+        (match table.current_row_group with
+        | Some group -> start_row_in_group group
+        | None -> failwith "Bug: just created row group")
+    | InImplicitRowGroup ->
+        table.state <- InRowInImplicitRowGroup;
+        table.current_col_range <- table.first_col_range;
+        table.previous_col_range <- None;
+        (match table.current_row_group with
+        | Some group -> start_row_in_group group
+        | None -> failwith "Bug: InImplicitRowGroup but no row group")
+    | InRowGroup ->
+        table.state <- InRowInRowGroup;
+        table.current_col_range <- table.first_col_range;
+        table.previous_col_range <- None;
+        (match table.current_row_group with
+        | Some group -> start_row_in_group group
+        | None -> failwith "Bug: InRowGroup but no row group")
+    | _ -> table.suppressed_starts <- 1
+
+(** End a row *)
+let end_row table collector =
+  if need_suppress_end table then ()
+  else
+    match table.state with
+    | InRowInRowGroup ->
+        table.state <- InRowGroup;
+        (match table.current_row_group with
+        | Some group ->
+            let row_width = end_row_in_group group collector in
+            (* Check row width against column count *)
+            if table.hard_width then (
+              if row_width > table.column_count then
+                Message_collector.add_error collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide and exceeded the column count established using column markup (%d).|}
+                       row_width table.column_count)
+                  ()
+              else if row_width < table.column_count then
+                Message_collector.add_error collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide, which is less than the column count established using column markup (%d).|}
+                       row_width table.column_count)
+                  ())
+            else if table.column_count = -1 then
+              table.column_count <- row_width
+            else (
+              if row_width > table.column_count then
+                Message_collector.add_warning collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide and exceeded the column count established by the first row (%d).|}
+                       row_width table.column_count)
+                  ()
+              else if row_width < table.column_count then
+                Message_collector.add_warning collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide, which is less than the column count established by the first row (%d).|}
+                       row_width table.column_count)
+                  ())
+        | None -> failwith "Bug: InRowInRowGroup but no row group")
+    | InRowInImplicitRowGroup ->
+        table.state <- InImplicitRowGroup;
+        (match table.current_row_group with
+        | Some group ->
+            let row_width = end_row_in_group group collector in
+            (* Same column count checking as above *)
+            if table.hard_width then (
+              if row_width > table.column_count then
+                Message_collector.add_error collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide and exceeded the column count established using column markup (%d).|}
+                       row_width table.column_count)
+                  ()
+              else if row_width < table.column_count then
+                Message_collector.add_error collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide, which is less than the column count established using column markup (%d).|}
+                       row_width table.column_count)
+                  ())
+            else if table.column_count = -1 then
+              table.column_count <- row_width
+            else (
+              if row_width > table.column_count then
+                Message_collector.add_warning collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide and exceeded the column count established by the first row (%d).|}
+                       row_width table.column_count)
+                  ()
+              else if row_width < table.column_count then
+                Message_collector.add_warning collector
+                  ~message:
+                    (Printf.sprintf
+                       {|A table row was %d columns wide, which is less than the column count established by the first row (%d).|}
+                       row_width table.column_count)
+                  ())
+        | None -> failwith "Bug: InRowInImplicitRowGroup but no row group")
+    | _ -> failwith "Bug: end_row in wrong state"
+
+(** Start a cell *)
+let start_cell table is_header attrs collector =
+  if need_suppress_start table then ()
+  else
+    match table.state with
+    | InRowInRowGroup ->
+        table.state <- InCellInRowGroup;
+        (* Record header ID if present *)
+        if is_header then (
+          match List.assoc_opt "id" attrs with
+          | Some id when String.length id > 0 -> Hashtbl.replace table.header_ids id ()
+          | _ -> ());
+        (* Parse cell attributes *)
+        let colspan = abs (parse_positive_int attrs "colspan") in
+        let rowspan = abs (parse_non_negative_int attrs "rowspan") in
+        let headers = parse_headers attrs in
+        let cell = make_cell ~colspan ~rowspan ~headers ~is_header collector in
+        if List.length headers > 0 then table.cells_with_headers := cell :: !(table.cells_with_headers);
+        (match table.current_row_group with
+        | Some group ->
+            add_cell_to_group group cell collector;
+            report_cell_to_table table cell
+        | None -> failwith "Bug: InRowInRowGroup but no row group")
+    | InRowInImplicitRowGroup ->
+        table.state <- InCellInImplicitRowGroup;
+        (* Same logic as above *)
+        if is_header then (
+          match List.assoc_opt "id" attrs with
+          | Some id when String.length id > 0 -> Hashtbl.replace table.header_ids id ()
+          | _ -> ());
+        let colspan = abs (parse_positive_int attrs "colspan") in
+        let rowspan = abs (parse_non_negative_int attrs "rowspan") in
+        let headers = parse_headers attrs in
+        let cell = make_cell ~colspan ~rowspan ~headers ~is_header collector in
+        if List.length headers > 0 then table.cells_with_headers := cell :: !(table.cells_with_headers);
+        (match table.current_row_group with
+        | Some group ->
+            add_cell_to_group group cell collector;
+            report_cell_to_table table cell
+        | None -> failwith "Bug: InRowInImplicitRowGroup but no row group")
+    | _ -> table.suppressed_starts <- 1
+
+(** End a cell *)
+let end_cell table =
+  if need_suppress_end table then ()
+  else
+    match table.state with
+    | InCellInRowGroup -> table.state <- InRowInRowGroup
+    | InCellInImplicitRowGroup -> table.state <- InRowInImplicitRowGroup
+    | _ -> failwith "Bug: end_cell in wrong state"
+
+(** Start a colgroup *)
+let start_colgroup table attrs collector =
+  if need_suppress_start table then ()
+  else
+    match table.state with
+    | InTableAtStart ->
+        table.hard_width <- true;
+        table.column_count <- 0;
+        table.pending_colgroup_span <- parse_span attrs collector;
+        table.state <- InColgroup
+    | InTableColsSeen ->
+        table.pending_colgroup_span <- parse_span attrs collector;
+        table.state <- InColgroup
+    | _ -> table.suppressed_starts <- 1
+
+(** End a colgroup *)
+let end_colgroup table =
+  if need_suppress_end table then ()
+  else
+    match table.state with
+    | InColgroup ->
+        if table.pending_colgroup_span <> 0 then (
+          let right = table.column_count + abs table.pending_colgroup_span in
+          let range = make_column_range ~element:"colgroup" ~left:table.column_count ~right in
+          append_column_range table range;
+          table.column_count <- right);
+        table.real_column_count <- table.column_count;
+        table.state <- InTableColsSeen
+    | _ -> failwith "Bug: end_colgroup in wrong state"
+
+(** Start a col *)
+let start_col table attrs collector =
+  if need_suppress_start table then ()
+  else
+    match table.state with
+    | InTableAtStart ->
+        table.hard_width <- true;
+        table.column_count <- 0;
+        table.state <- InColInImplicitGroup;
+        let span = abs (parse_span attrs collector) in
+        let right = table.column_count + span in
+        let range = make_column_range ~element:"col" ~left:table.column_count ~right in
+        append_column_range table range;
+        table.column_count <- right;
+        table.real_column_count <- table.column_count
+    | InTableColsSeen ->
+        table.state <- InColInImplicitGroup;
+        let span = abs (parse_span attrs collector) in
+        let right = table.column_count + span in
+        let range = make_column_range ~element:"col" ~left:table.column_count ~right in
+        append_column_range table range;
+        table.column_count <- right;
+        table.real_column_count <- table.column_count
+    | InColgroup ->
+        if table.pending_colgroup_span > 0 then
+          Message_collector.add_warning collector
+            ~message:
+              (Printf.sprintf
+                 "A col element causes a span attribute with value %d to be ignored on the \
+                  parent colgroup."
+                 table.pending_colgroup_span)
+            ();
+        table.pending_colgroup_span <- 0;
+        table.state <- InColInColgroup;
+        let span = abs (parse_span attrs collector) in
+        let right = table.column_count + span in
+        let range = make_column_range ~element:"col" ~left:table.column_count ~right in
+        append_column_range table range;
+        table.column_count <- right;
+        table.real_column_count <- table.column_count
+    | _ -> table.suppressed_starts <- 1
+
+(** End a col *)
+let end_col table =
+  if need_suppress_end table then ()
+  else
+    match table.state with
+    | InColInImplicitGroup -> table.state <- InTableColsSeen
+    | InColInColgroup -> table.state <- InColgroup
+    | _ -> failwith "Bug: end_col in wrong state"
+
+(** End a table *)
+let end_table table collector =
+  (match table.state with
+  | InImplicitRowGroup -> (
+      match table.current_row_group with
+      | Some group ->
+          end_row_group group collector;
+          table.current_row_group <- None
+      | None -> failwith "Bug: InImplicitRowGroup but no row group")
+  | InTableAtStart | InTableAtPotentialRowGroupStart | InTableColsSeen -> ()
+  | _ -> failwith "Bug: end_table in wrong state");
+
+  (* Check header reference integrity *)
+  List.iter
+    (fun cell ->
+      List.iter
+        (fun heading ->
+          if not (Hashtbl.mem table.header_ids heading) then
+            Message_collector.add_error collector
+              ~message:
+                (Printf.sprintf
+                   {|The "headers" attribute on the element "%s" refers to the ID "%s", but there is no "th" element with that ID in the same table.|}
+                   cell.element_name heading)
+              ())
+        cell.headers)
+    !(table.cells_with_headers);
+
+  (* Check that each column established by col/colgroup has cells *)
+  let rec check_ranges range =
+    match range with
+    | None -> ()
+    | Some r ->
+        if is_single_col r then
+          Message_collector.add_error collector
+            ~message:
+              (Printf.sprintf {|Table column %d established by element "%s" has no cells beginning in it.|}
+                 r.right r.element)
+            ()
+        else
+          Message_collector.add_error collector
+            ~message:
+              (Printf.sprintf
+                 {|Table columns in range %d…%d established by element "%s" have no cells beginning in them.|}
+                 (r.left + 1) r.right r.element)
+            ();
+        check_ranges r.next
+  in
+  check_ranges table.first_col_range
+
+(** {1 Checker State} *)
+
+type state = { tables : table list ref (* Stack of nested tables *) }
+
+let create () = { tables = ref [] }
+
+let reset state = state.tables := []
+
+let start_element state ~name ~namespace ~attrs collector =
+  match namespace with
+  | Some ns when ns = html_ns -> (
+      match name with
+      | "table" ->
+          (* Push a new table onto the stack *)
+          state.tables := make_table () :: !(state.tables)
+      | _ -> (
+          match !(state.tables) with
+          | [] -> ()
+          | table :: _ -> (
+              match name with
+              | "td" -> start_cell table false attrs collector
+              | "th" -> start_cell table true attrs collector
+              | "tr" -> start_row table collector
+              | "tbody" | "thead" | "tfoot" -> start_row_group table name collector
+              | "col" -> start_col table attrs collector
+              | "colgroup" -> start_colgroup table attrs collector
+              | _ -> ())))
+  | _ -> ()
+
+let end_element state ~name ~namespace collector =
+  match namespace with
+  | Some ns when ns = html_ns -> (
+      match name with
+      | "table" -> (
+          match !(state.tables) with
+          | [] -> failwith "Bug: end table but no table on stack"
+          | table :: rest ->
+              end_table table collector;
+              state.tables := rest)
+      | _ -> (
+          match !(state.tables) with
+          | [] -> ()
+          | table :: _ -> (
+              match name with
+              | "td" | "th" -> end_cell table
+              | "tr" -> end_row table collector
+              | "tbody" | "thead" | "tfoot" -> end_row_group_handler table collector
+              | "col" -> end_col table
+              | "colgroup" -> end_colgroup table
+              | _ -> ())))
+  | _ -> ()
+
+let characters _state _text _collector = ()
+
+let end_document state collector =
+  if !(state.tables) <> [] then
+    Message_collector.add_error collector ~message:"Unclosed table element at end of document." ()
+
+let checker =
+  (module struct
+    type nonrec state = state
+
+    let create = create
+    let reset = reset
+    let start_element = start_element
+    let end_element = end_element
+    let characters = characters
+    let end_document = end_document
+  end : Checker.S)

lib/html5_checker/specialized/table_checker.mli

···
+(** Table structure validation checker.
+
+    Validates HTML table integrity including:
+    - Cell overlap detection (rowspan/colspan causing overlap)
+    - Spanning past table boundaries
+    - Proper table structure (thead/tbody/tfoot ordering)
+    - Maximum colspan limit (1000 per HTML spec)
+    - Maximum rowspan limit (65534 per HTML spec)
+
+    {2 Validation Rules}
+
+    {b Cell Positioning}
+    - Detects when two cells claim the same grid position
+    - Validates that rowspan/colspan don't cause cells to extend past boundaries
+    - Tracks cell positions accounting for rowspan/colspan from previous rows
+
+    {b Span Limits}
+    - [colspan] must be positive and <= 1000
+    - [rowspan] must be non-negative and <= 65534
+    - [rowspan=0] is a special value meaning "span to end of row group"
+
+    {b Table Structure}
+    - [caption] must be first child of [table] if present
+    - [thead] must come before [tbody] and [tfoot]
+    - Only one [thead] and one [tfoot] allowed per table
+    - [col] elements can establish explicit column count
+    - [colgroup] elements can group columns
+
+    {b Row Validation}
+    - Each row must have at least one cell
+    - Row widths should match the established column count
+    - Cells cannot overlap horizontally in the same row
+
+    {b Header References}
+    - [headers] attribute on [td]/[th] must reference valid [th] IDs
+    - All referenced header IDs must exist in the same table
+
+    {3 Example Valid Table}
+
+    {v
+    <table>
+      <thead>
+        <tr>
+          <th id="h1">Header 1</th>
+          <th id="h2">Header 2</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td headers="h1">Cell 1</td>
+          <td headers="h2">Cell 2</td>
+        </tr>
+      </tbody>
+    </table>
+    v}
+
+    {3 Example Invalid Table (Overlapping Cells)}
+
+    {v
+    <table>
+      <tr>
+        <td rowspan="2">A</td>
+        <td>B</td>
+      </tr>
+      <tr>
+        <td>C</td>  <!-- Would overlap with A's rowspan -->
+      </tr>
+    </table>
+    v}
+
+    @see <https://html.spec.whatwg.org/multipage/tables.html> WHATWG HTML: Tables
+    @see <https://www.w3.org/TR/html52/tabular-data.html> W3C HTML 5.2: Tables *)
+
+include Checker.S
+
+val checker : Checker.t
+(** A first-class module instance of this checker.
+
+    {b Usage:}
+    {[
+      let checker = Table_checker.checker in
+      Checker_registry.register "table-structure" checker
+    ]} *)

lib/html5rw/parser/parser_impl.ml

···
 module TreeBuilderSink = struct
   type t = Parser_tree_builder.t
 
-  let process tb token =
+  let process tb token ~line ~column =
+    Parser_tree_builder.set_position tb ~line ~column;
     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 *)

lib/html5rw/parser/parser_tree_builder.ml

···
   fragment_context : fragment_context option;
   mutable fragment_context_element : Dom.node option;
   iframe_srcdoc : bool;
+  mutable current_line : int;
+  mutable current_column : int;
 }
 
 let create ?(collect_errors=false) ?fragment_context ?(iframe_srcdoc=false) () =
···
     fragment_context;
     fragment_context_element = None;
     iframe_srcdoc;
+    current_line = 1;
+    current_column = 1;
   } in
   (* Initialize fragment parsing *)
   (match fragment_context with
···
   | None -> ());
   t
 
+(* Position tracking for error reporting *)
+let set_position t ~line ~column =
+  t.current_line <- line;
+  t.current_column <- column
+
 (* Error handling *)
 let parse_error t code =
   if t.collect_errors then
-    t.errors <- { code = Parse_error_code.of_string code; line = 0; column = 0 } :: t.errors
+    t.errors <- { code = Parse_error_code.of_string code; line = t.current_line; column = t.current_column } :: t.errors
 
 (* Stack helpers *)
 let current_node t =

lib/html5rw/tokenizer/tokenizer.mli

···
 *)
 module type SINK = sig
   type t
-  val process : t -> Tokenizer_token.t -> [ `Continue | `SwitchTo of Tokenizer_state.t ]
+  val process : t -> Tokenizer_token.t -> line:int -> column:int -> [ `Continue | `SwitchTo of Tokenizer_state.t ]
   val adjusted_current_node_in_html_namespace : t -> bool
 end
 

lib/html5rw/tokenizer/tokenizer_impl.ml

···
 (* Token sink interface *)
 module type SINK = sig
   type t
-  val process : t -> Tokenizer_token.t -> [ `Continue | `SwitchTo of Tokenizer_state.t ]
+  val process : t -> Tokenizer_token.t -> line:int -> column:int -> [ `Continue | `SwitchTo of Tokenizer_state.t ]
   val adjusted_current_node_in_html_namespace : t -> bool
 end
 
···
       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))
+      let line, column = Tokenizer_stream.position t.stream in
+      ignore (S.process t.sink (Tokenizer_token.Character data) ~line ~column)
     end
   in
 
   let emit token =
     emit_pending_chars ();
-    match S.process t.sink token with
+    let line, column = Tokenizer_stream.position t.stream in
+    match S.process t.sink token ~line ~column with
     | `Continue -> ()
     | `SwitchTo new_state -> t.state <- new_state
   in
···
       handle_eof ()
     end else if Tokenizer_stream.is_eof t.stream then begin
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     end else begin
       step ();
       process_state ()
···
     match t.state with
     | Tokenizer_state.Data ->
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Tag_open ->
       error t "eof-before-tag-name";
       emit_char t '<';
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Tag_name
     | Tokenizer_state.Before_attribute_name
     | Tokenizer_state.Attribute_name
···
     | Tokenizer_state.Self_closing_start_tag ->
       error t "eof-in-tag";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Rawtext ->
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Rawtext_less_than_sign ->
       emit_char t '<';
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Rawtext_end_tag_open ->
       emit_str t "</";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Rcdata ->
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Rcdata_less_than_sign ->
       emit_char t '<';
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Rcdata_end_tag_open ->
       emit_str t "</";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data ->
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data_less_than_sign ->
       emit_char t '<';
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data_end_tag_open ->
       emit_str t "</";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data_escape_start
     | Tokenizer_state.Script_data_escape_start_dash
     | Tokenizer_state.Script_data_escaped
···
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data_escaped_less_than_sign ->
       emit_char t '<';
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data_escaped_end_tag_open ->
       emit_str t "</";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Script_data_double_escape_end ->
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Plaintext ->
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Comment_start
     | Tokenizer_state.Comment_start_dash
     | Tokenizer_state.Comment
···
       error t "eof-in-comment";
       emit_current_comment ();
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Bogus_comment ->
       emit_current_comment ();
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | 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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Doctype
     | Tokenizer_state.Before_doctype_name ->
       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)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Doctype_name
     | Tokenizer_state.After_doctype_name
     | Tokenizer_state.After_doctype_public_keyword
···
       t.current_doctype_force_quirks <- true;
       emit_current_doctype ();
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Bogus_doctype ->
       emit_current_doctype ();
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Cdata_section ->
       error t "eof-in-cdata";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Cdata_section_bracket ->
       error t "eof-in-cdata";
       emit_char t ']';
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Cdata_section_end ->
       error t "eof-in-cdata";
       emit_str t "]]";
       emit_pending_chars ();
-      ignore (S.process t.sink Tokenizer_token.EOF)
+      let line, column = Tokenizer_stream.position t.stream in ignore (S.process t.sink Tokenizer_token.EOF ~line ~column)
     | Tokenizer_state.Character_reference ->
       (* state_character_reference never ran, so initialize temp_buffer with & *)
       Buffer.clear t.temp_buffer;
···
       (* 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"))
+      let line, column = Tokenizer_stream.position t.stream in
+      ignore (S.process t.sink (Tokenizer_token.Character "\x00") ~line ~column)
     | Some c ->
       emit_char_checked c
     | None -> ()

test/dune

···
   (glob_files ../html5lib-tests/serializer/*.test))
  (action
   (run %{exe:test_serializer.exe} ../html5lib-tests/serializer)))
+
+(executable
+ (name test_nesting_checker)
+ (modules test_nesting_checker)
+ (libraries html5rw.checker))
+
+(executable
+ (name test_html5_checker)
+ (modules test_html5_checker)
+ (libraries bytesrw html5rw html5rw.checker str))
+
+(rule
+ (alias runtest)
+ (action
+  (run %{exe:test_html5_checker.exe})))

test/test_html5_checker.ml

···
+(** Tests for the html5_checker library *)
+
+(** Helper to create a reader from a string *)
+let reader_of_string s = Bytesrw.Bytes.Reader.of_string s
+
+(** Helper to check if a message contains a substring *)
+let message_contains msg substring =
+  String.lowercase_ascii msg.Html5_checker.Message.message
+  |> fun s -> String.length s >= String.length substring &&
+    try
+      ignore (Str.search_forward (Str.regexp_case_fold (Str.quote substring)) s 0);
+      true
+    with Not_found -> false
+
+(** Test that valid HTML5 produces no errors *)
+let test_valid_html5 () =
+  Printf.printf "Test 1: Valid HTML5 document\n";
+  let html = {|<!DOCTYPE html>
+<html lang="en">
+<head><title>Test</title></head>
+<body><p>Hello world</p></body>
+</html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let errors = Html5_checker.errors result in
+  Printf.printf "  Found %d error(s)\n" (List.length errors);
+  if List.length errors > 0 then begin
+    List.iter (fun msg ->
+      Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+    ) errors;
+  end else
+    Printf.printf "    OK: No errors as expected\n"
+
+(** Test that missing DOCTYPE is detected *)
+let test_missing_doctype () =
+  Printf.printf "\nTest 2: Missing DOCTYPE\n";
+  let html = "<html><body>Hello</body></html>" in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let errors = Html5_checker.errors result in
+  Printf.printf "  Found %d error(s)\n" (List.length errors);
+  if List.length errors = 0 then
+    Printf.printf "    Warning: Expected parse errors for missing DOCTYPE\n"
+  else begin
+    List.iter (fun msg ->
+      Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+    ) errors;
+  end
+
+(** Test that obsolete elements are detected *)
+let test_obsolete_element () =
+  Printf.printf "\nTest 3: Obsolete <center> element\n";
+  let html = "<!DOCTYPE html><html><body><center>Centered</center></body></html>" in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  Found %d message(s)\n" (List.length all_msgs);
+  let obsolete_msgs = List.filter (fun m ->
+    message_contains m "obsolete" || message_contains m "center"
+  ) all_msgs in
+  if List.length obsolete_msgs > 0 then begin
+    Printf.printf "    Found obsolete-related messages:\n";
+    List.iter (fun msg ->
+      Printf.printf "      - %s\n" msg.Html5_checker.Message.message
+    ) obsolete_msgs;
+  end else
+    Printf.printf "    Note: No obsolete element warnings found (checker may not be enabled)\n"
+
+(** Test duplicate IDs *)
+let test_duplicate_id () =
+  Printf.printf "\nTest 4: Duplicate ID attributes\n";
+  let html = {|<!DOCTYPE html><html><body>
+    <div id="foo">First</div>
+    <div id="foo">Second</div>
+  </body></html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  Found %d message(s)\n" (List.length all_msgs);
+  let id_msgs = List.filter (fun m ->
+    message_contains m "duplicate" || message_contains m "id"
+  ) all_msgs in
+  if List.length id_msgs > 0 then begin
+    Printf.printf "    Found ID-related messages:\n";
+    List.iter (fun msg ->
+      Printf.printf "      - %s\n" msg.Html5_checker.Message.message
+    ) id_msgs;
+  end else
+    Printf.printf "    Note: No duplicate ID errors found (checker may not be enabled)\n"
+
+(** Test heading structure *)
+let test_heading_skip () =
+  Printf.printf "\nTest 5: Skipped heading level\n";
+  let html = {|<!DOCTYPE html><html><body>
+    <h1>Title</h1>
+    <h3>Skipped h2</h3>
+  </body></html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  Found %d message(s)\n" (List.length all_msgs);
+  let heading_msgs = List.filter (fun m ->
+    message_contains m "heading" || message_contains m "skip"
+  ) all_msgs in
+  if List.length heading_msgs > 0 then begin
+    Printf.printf "    Found heading-related messages:\n";
+    List.iter (fun msg ->
+      Printf.printf "      - %s\n" msg.Html5_checker.Message.message
+    ) heading_msgs;
+  end else
+    Printf.printf "    Note: No heading structure warnings found (checker may not be enabled)\n"
+
+(** Test img without alt *)
+let test_img_without_alt () =
+  Printf.printf "\nTest 6: Image without alt attribute\n";
+  let html = {|<!DOCTYPE html><html><body>
+    <img src="test.jpg">
+  </body></html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  Found %d message(s)\n" (List.length all_msgs);
+  let img_msgs = List.filter (fun m ->
+    message_contains m "alt" || (message_contains m "img" && message_contains m "attribute")
+  ) all_msgs in
+  if List.length img_msgs > 0 then begin
+    Printf.printf "    Found img/alt-related messages:\n";
+    List.iter (fun msg ->
+      Printf.printf "      - %s\n" msg.Html5_checker.Message.message
+    ) img_msgs;
+  end else
+    Printf.printf "    Note: No missing alt attribute errors found (checker may not be enabled)\n"
+
+(** Test invalid nesting *)
+let test_invalid_nesting () =
+  Printf.printf "\nTest 7: Invalid nesting - <a> inside <a>\n";
+  let html = {|<!DOCTYPE html><html><body>
+    <a href="#">Link <a href="#">Nested</a></a>
+  </body></html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  Found %d message(s)\n" (List.length all_msgs);
+  let nesting_msgs = List.filter (fun m ->
+    message_contains m "nesting" || message_contains m "nested" || message_contains m "ancestor"
+  ) all_msgs in
+  if List.length nesting_msgs > 0 then begin
+    Printf.printf "    Found nesting-related messages:\n";
+    List.iter (fun msg ->
+      Printf.printf "      - %s\n" msg.Html5_checker.Message.message
+    ) nesting_msgs;
+  end else
+    Printf.printf "    Note: No nesting errors found (checker may not be enabled)\n"
+
+(** Test form inside form *)
+let test_form_nesting () =
+  Printf.printf "\nTest 8: Invalid nesting - <form> inside <form>\n";
+  let html = {|<!DOCTYPE html><html><body>
+    <form><form></form></form>
+  </body></html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  Found %d message(s)\n" (List.length all_msgs);
+  let form_msgs = List.filter (fun m ->
+    message_contains m "form"
+  ) all_msgs in
+  if List.length form_msgs > 0 then begin
+    Printf.printf "    Found form-related messages:\n";
+    List.iter (fun msg ->
+      Printf.printf "      - %s\n" msg.Html5_checker.Message.message
+    ) form_msgs;
+  end else
+    Printf.printf "    Note: No form nesting errors found (checker may not be enabled)\n"
+
+(** Test output formatting *)
+let test_output_formats () =
+  Printf.printf "\nTest 9: Output format testing\n";
+  let html = {|<!DOCTYPE html><html><body><p>Test</p></body></html>|} in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+
+  Printf.printf "  Testing text format:\n";
+  let text_output = Html5_checker.format_text result in
+  Printf.printf "    Length: %d chars\n" (String.length text_output);
+
+  Printf.printf "  Testing JSON format:\n";
+  let json_output = Html5_checker.format_json result in
+  Printf.printf "    Length: %d chars\n" (String.length json_output);
+
+  Printf.printf "  Testing GNU format:\n";
+  let gnu_output = Html5_checker.format_gnu result in
+  Printf.printf "    Length: %d chars\n" (String.length gnu_output)
+
+(** Test has_errors function *)
+let test_has_errors () =
+  Printf.printf "\nTest 10: has_errors function\n";
+
+  (* Valid document should have no errors *)
+  let valid_html = "<!DOCTYPE html><html><body><p>Valid</p></body></html>" in
+  let result1 = Html5_checker.check (reader_of_string valid_html) in
+  Printf.printf "  Valid document has_errors: %b\n" (Html5_checker.has_errors result1);
+
+  (* Document with likely parse errors *)
+  let invalid_html = "<html><body><p>Unclosed" in
+  let result2 = Html5_checker.check (reader_of_string invalid_html) in
+  Printf.printf "  Invalid document has_errors: %b\n" (Html5_checker.has_errors result2)
+
+(** Test check_dom with pre-parsed document *)
+let test_check_dom () =
+  Printf.printf "\nTest 11: check_dom with pre-parsed document\n";
+  let html = "<!DOCTYPE html><html><body><p>Test</p></body></html>" in
+  let reader = reader_of_string html in
+  let parsed = Html5rw.parse reader in
+  let result = Html5_checker.check_dom parsed in
+  let all_msgs = Html5_checker.messages result in
+  Printf.printf "  check_dom found %d message(s)\n" (List.length all_msgs);
+  Printf.printf "    OK: check_dom completed successfully\n"
+
+(** Test system_id parameter *)
+let test_system_id () =
+  Printf.printf "\nTest 12: system_id parameter\n";
+  let html = "<!DOCTYPE html><html><body><p>Test</p></body></html>" in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check ~system_id:"test.html" reader in
+  match Html5_checker.system_id result with
+  | Some id -> Printf.printf "  system_id: %s\n" id
+  | None -> Printf.printf "  Warning: system_id not set\n"
+
+(** Test collect_parse_errors flag *)
+let test_collect_parse_errors_flag () =
+  Printf.printf "\nTest 13: collect_parse_errors flag\n";
+  let html = "<!DOCTYPE html><html><body><p>Test</p></body></html>" in
+
+  let result_with = Html5_checker.check ~collect_parse_errors:true (reader_of_string html) in
+  let msgs_with = Html5_checker.messages result_with in
+  Printf.printf "  With parse errors: %d message(s)\n" (List.length msgs_with);
+
+  let result_without = Html5_checker.check ~collect_parse_errors:false (reader_of_string html) in
+  let msgs_without = Html5_checker.messages result_without in
+  Printf.printf "  Without parse errors: %d message(s)\n" (List.length msgs_without)
+
+(** Test document accessor *)
+let test_document_accessor () =
+  Printf.printf "\nTest 14: document accessor\n";
+  let html = "<!DOCTYPE html><html><body><p>Test</p></body></html>" in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+  let _doc = Html5_checker.document result in
+  Printf.printf "    OK: document accessor works\n"
+
+(** Test message severity filtering *)
+let test_severity_filtering () =
+  Printf.printf "\nTest 15: Message severity filtering\n";
+  let html = "<!DOCTYPE html><html><body><p>Test</p></body></html>" in
+  let reader = reader_of_string html in
+  let result = Html5_checker.check reader in
+
+  let all_msgs = Html5_checker.messages result in
+  let errors = Html5_checker.errors result in
+  let warnings = Html5_checker.warnings result in
+
+  Printf.printf "  Total messages: %d\n" (List.length all_msgs);
+  Printf.printf "  Errors: %d\n" (List.length errors);
+  Printf.printf "  Warnings: %d\n" (List.length warnings);
+
+  (* Verify that errors + warnings <= all messages *)
+  if List.length errors + List.length warnings <= List.length all_msgs then
+    Printf.printf "    OK: Message counts are consistent\n"
+  else
+    Printf.printf "    Warning: Message counts inconsistent\n"
+
+(** Run all tests *)
+let () =
+  Printf.printf "Running html5_checker tests...\n";
+  Printf.printf "========================================\n\n";
+
+  test_valid_html5 ();
+  test_missing_doctype ();
+  test_obsolete_element ();
+  test_duplicate_id ();
+  test_heading_skip ();
+  test_img_without_alt ();
+  test_invalid_nesting ();
+  test_form_nesting ();
+  test_output_formats ();
+  test_has_errors ();
+  test_check_dom ();
+  test_system_id ();
+  test_collect_parse_errors_flag ();
+  test_document_accessor ();
+  test_severity_filtering ();
+
+  Printf.printf "\n========================================\n";
+  Printf.printf "All tests completed!\n";
+  Printf.printf "\nNote: Some checkers may not be enabled yet.\n";
+  Printf.printf "Tests marked with 'Note:' indicate features that may be\n";
+  Printf.printf "implemented in future versions.\n"

test/test_nesting_checker.ml

···
+(** Simple test for nesting_checker functionality *)
+
+let () =
+  (* Create a message collector *)
+  let collector = Html5_checker.Message_collector.create () in
+
+  (* Get the nesting checker *)
+  let module C = (val Html5_checker__Nesting_checker.checker : Html5_checker__Checker.S) in
+  let state = C.create () in
+
+  (* Test 1: <a> cannot contain another <a> *)
+  Printf.printf "Test 1: Checking <a href> inside <a href>\n";
+  C.start_element state ~name:"a" ~namespace:None ~attrs:[("href", "#")] collector;
+  C.start_element state ~name:"a" ~namespace:None ~attrs:[("href", "#")] collector;
+
+  let errors1 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors1);
+  List.iter (fun msg ->
+    Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+  ) errors1;
+
+  C.end_element state ~name:"a" ~namespace:None collector;
+  C.end_element state ~name:"a" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 2: <button> inside <a> *)
+  Printf.printf "\nTest 2: Checking <button> inside <a href>\n";
+  C.start_element state ~name:"a" ~namespace:None ~attrs:[("href", "#")] collector;
+  C.start_element state ~name:"button" ~namespace:None ~attrs:[] collector;
+
+  let errors2 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors2);
+  List.iter (fun msg ->
+    Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+  ) errors2;
+
+  C.end_element state ~name:"button" ~namespace:None collector;
+  C.end_element state ~name:"a" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 3: form inside form *)
+  Printf.printf "\nTest 3: Checking <form> inside <form>\n";
+  C.start_element state ~name:"form" ~namespace:None ~attrs:[] collector;
+  C.start_element state ~name:"form" ~namespace:None ~attrs:[] collector;
+
+  let errors3 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors3);
+  List.iter (fun msg ->
+    Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+  ) errors3;
+
+  C.end_element state ~name:"form" ~namespace:None collector;
+  C.end_element state ~name:"form" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 4: header inside footer *)
+  Printf.printf "\nTest 4: Checking <header> inside <footer>\n";
+  C.start_element state ~name:"footer" ~namespace:None ~attrs:[] collector;
+  C.start_element state ~name:"header" ~namespace:None ~attrs:[] collector;
+
+  let errors4 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors4);
+  List.iter (fun msg ->
+    Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+  ) errors4;
+
+  C.end_element state ~name:"header" ~namespace:None collector;
+  C.end_element state ~name:"footer" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 5: input (not hidden) inside button *)
+  Printf.printf "\nTest 5: Checking <input type=text> inside <button>\n";
+  C.start_element state ~name:"button" ~namespace:None ~attrs:[] collector;
+  C.start_element state ~name:"input" ~namespace:None ~attrs:[("type", "text")] collector;
+
+  let errors5 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors5);
+  List.iter (fun msg ->
+    Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+  ) errors5;
+
+  C.end_element state ~name:"input" ~namespace:None collector;
+  C.end_element state ~name:"button" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 6: valid nesting - should not error *)
+  Printf.printf "\nTest 6: Checking valid nesting: <div> inside <div>\n";
+  C.start_element state ~name:"div" ~namespace:None ~attrs:[] collector;
+  C.start_element state ~name:"div" ~namespace:None ~attrs:[] collector;
+
+  let errors6 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors6);
+  if List.length errors6 = 0 then
+    Printf.printf "    OK: No errors as expected\n";
+
+  C.end_element state ~name:"div" ~namespace:None collector;
+  C.end_element state ~name:"div" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 7: area without map ancestor *)
+  Printf.printf "\nTest 7: Checking <area> without <map> ancestor\n";
+  C.start_element state ~name:"area" ~namespace:None ~attrs:[] collector;
+
+  let errors7 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors7);
+  List.iter (fun msg ->
+    Printf.printf "    - %s\n" msg.Html5_checker.Message.message
+  ) errors7;
+
+  C.end_element state ~name:"area" ~namespace:None collector;
+  Html5_checker.Message_collector.clear collector;
+
+  (* Test 8: area with map ancestor (valid) *)
+  Printf.printf "\nTest 8: Checking <area> with <map> ancestor (valid)\n";
+  C.start_element state ~name:"map" ~namespace:None ~attrs:[] collector;
+  C.start_element state ~name:"area" ~namespace:None ~attrs:[] collector;
+
+  let errors8 = Html5_checker.Message_collector.errors collector in
+  Printf.printf "  Found %d error(s)\n" (List.length errors8);
+  if List.length errors8 = 0 then
+    Printf.printf "    OK: No errors as expected\n";
+
+  C.end_element state ~name:"area" ~namespace:None collector;
+  C.end_element state ~name:"map" ~namespace:None collector;
+
+  Printf.printf "\nAll tests completed!\n"