more

lib/html5_checker/checker_registry.ml

···
   Hashtbl.replace reg "option" Option_checker.checker;
   Hashtbl.replace reg "language" Language_checker.checker;
   Hashtbl.replace reg "microdata" Microdata_checker.checker;
-  (* Hashtbl.replace reg "table" Table_checker.checker; *)
+  Hashtbl.replace reg "importmap" Importmap_checker.checker;
+  Hashtbl.replace reg "table" Table_checker.checker;
+  Hashtbl.replace reg "mime-type" Mime_type_checker.checker;
   (* Hashtbl.replace reg "heading" Heading_checker.checker; *)
   (* Hashtbl.replace reg "content" Content_checker.checker; *)
   reg

lib/html5_checker/specialized/importmap_checker.ml

···
+(** Importmap validation checker.
+
+    Validates that <script type="importmap"> elements contain valid JSON
+    and conform to importmap structural requirements. *)
+
+type state = {
+  mutable in_importmap : bool;
+  content : Buffer.t;
+}
+
+let create () = {
+  in_importmap = false;
+  content = Buffer.create 256;
+}
+
+let reset state =
+  state.in_importmap <- false;
+  Buffer.clear state.content
+
+(** Simple JSON value representation *)
+type json =
+  | JNull
+  | JBool of bool
+  | JNumber of float
+  | JString of string
+  | JArray of json list
+  | JObject of (string * json) list
+
+(** Simple JSON parser *)
+let parse_json s_orig =
+  let s = String.trim s_orig in
+  let len = String.length s in
+  if len = 0 then Error "Empty JSON"
+  else
+  let pos = ref 0 in
+
+  let skip_ws () =
+    while !pos < len && (s.[!pos] = ' ' || s.[!pos] = '\t' || s.[!pos] = '\n' || s.[!pos] = '\r') do
+      incr pos
+    done
+  in
+
+  let peek () = if !pos < len then Some s.[!pos] else None in
+  let consume () = let c = s.[!pos] in incr pos; c in
+
+  let rec parse_value () =
+    skip_ws ();
+    match peek () with
+    | None -> Error "Unexpected end of input"
+    | Some '{' -> parse_object ()
+    | Some '[' -> parse_array ()
+    | Some '"' -> parse_string ()
+    | Some 't' -> parse_true ()
+    | Some 'f' -> parse_false ()
+    | Some 'n' -> parse_null ()
+    | Some c when c = '-' || (c >= '0' && c <= '9') -> parse_number ()
+    | Some _ -> Error "Unexpected character"
+
+  and parse_object () =
+    ignore (consume ()); (* consume { *)
+    skip_ws ();
+    match peek () with
+    | Some '}' -> ignore (consume ()); Ok (JObject [])
+    | _ ->
+      let rec parse_members acc =
+        skip_ws ();
+        match parse_string () with
+        | Error e -> Error e
+        | Ok (JString key) ->
+          skip_ws ();
+          (match peek () with
+          | Some ':' ->
+            ignore (consume ());
+            (match parse_value () with
+            | Error e -> Error e
+            | Ok value ->
+              skip_ws ();
+              let acc' = (key, value) :: acc in
+              match peek () with
+              | Some ',' -> ignore (consume ()); parse_members acc'
+              | Some '}' -> ignore (consume ()); Ok (JObject (List.rev acc'))
+              | _ -> Error "Expected ',' or '}'")
+          | _ -> Error "Expected ':'")
+        | Ok _ -> Error "Expected string key"
+      in
+      parse_members []
+
+  and parse_array () =
+    ignore (consume ()); (* consume [ *)
+    skip_ws ();
+    match peek () with
+    | Some ']' -> ignore (consume ()); Ok (JArray [])
+    | _ ->
+      let rec parse_elements acc =
+        match parse_value () with
+        | Error e -> Error e
+        | Ok value ->
+          skip_ws ();
+          let acc' = value :: acc in
+          match peek () with
+          | Some ',' -> ignore (consume ()); parse_elements acc'
+          | Some ']' -> ignore (consume ()); Ok (JArray (List.rev acc'))
+          | _ -> Error "Expected ',' or ']'"
+      in
+      parse_elements []
+
+  and parse_string () =
+    skip_ws ();
+    match peek () with
+    | Some '"' ->
+      ignore (consume ());
+      let buf = Buffer.create 32 in
+      let rec read () =
+        match peek () with
+        | None -> Error "Unterminated string"
+        | Some '"' -> ignore (consume ()); Ok (JString (Buffer.contents buf))
+        | Some '\\' ->
+          ignore (consume ());
+          (match peek () with
+          | None -> Error "Unterminated escape"
+          | Some c -> ignore (consume ()); Buffer.add_char buf c; read ())
+        | Some c -> ignore (consume ()); Buffer.add_char buf c; read ()
+      in
+      read ()
+    | _ -> Error "Expected string"
+
+  and parse_number () =
+    let start = !pos in
+    if peek () = Some '-' then incr pos;
+    while !pos < len && s.[!pos] >= '0' && s.[!pos] <= '9' do incr pos done;
+    if !pos < len && s.[!pos] = '.' then begin
+      incr pos;
+      while !pos < len && s.[!pos] >= '0' && s.[!pos] <= '9' do incr pos done
+    end;
+    if !pos < len && (s.[!pos] = 'e' || s.[!pos] = 'E') then begin
+      incr pos;
+      if !pos < len && (s.[!pos] = '+' || s.[!pos] = '-') then incr pos;
+      while !pos < len && s.[!pos] >= '0' && s.[!pos] <= '9' do incr pos done
+    end;
+    let num_str = String.sub s start (!pos - start) in
+    match float_of_string_opt num_str with
+    | Some f -> Ok (JNumber f)
+    | None -> Error "Invalid number"
+
+  and parse_true () =
+    if !pos + 4 <= len && String.sub s !pos 4 = "true" then
+      (pos := !pos + 4; Ok (JBool true))
+    else Error "Expected 'true'"
+
+  and parse_false () =
+    if !pos + 5 <= len && String.sub s !pos 5 = "false" then
+      (pos := !pos + 5; Ok (JBool false))
+    else Error "Expected 'false'"
+
+  and parse_null () =
+    if !pos + 4 <= len && String.sub s !pos 4 = "null" then
+      (pos := !pos + 4; Ok JNull)
+    else Error "Expected 'null'"
+  in
+
+  match parse_value () with
+  | Error e -> Error e
+  | Ok v ->
+    skip_ws ();
+    if !pos = len then Ok v
+    else Error "Unexpected content after JSON"
+
+(** Validate importmap structure *)
+type importmap_error =
+  | InvalidJSON of string
+  | EmptyKey of string (* property name where empty key was found *)
+  | NotObject of string (* property name that should be object but isn't *)
+  | NotString of string (* property name that should be string but isn't *)
+  | ForbiddenProperty of string
+  | SlashKeyWithoutSlashValue of string (* property name where slash key doesn't have slash value *)
+  | InvalidScopeKey (* scope key is not a valid URL *)
+  | InvalidScopeValue of string (* scope value is not a valid URL *)
+
+(** Check if a string looks like a valid URL-like specifier for importmaps *)
+let is_valid_url_like s =
+  if String.length s = 0 then false
+  else
+    (* Valid URL-like: starts with /, ./, ../, or has a scheme followed by :// or : *)
+    let starts_with_slash = s.[0] = '/' in
+    let starts_with_dot_slash = String.length s >= 2 && s.[0] = '.' && s.[1] = '/' in
+    let starts_with_dot_dot_slash = String.length s >= 3 && s.[0] = '.' && s.[1] = '.' && s.[2] = '/' in
+    let has_scheme =
+      match String.index_opt s ':' with
+      | None -> false
+      | Some pos when pos > 0 ->
+        (* Check that characters before : are valid scheme characters *)
+        let scheme = String.sub s 0 pos in
+        String.length scheme > 0 &&
+        String.for_all (fun c ->
+          (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+          (c >= '0' && c <= '9') || c = '+' || c = '-' || c = '.'
+        ) scheme
+      | _ -> false
+    in
+    starts_with_slash || starts_with_dot_slash || starts_with_dot_dot_slash || has_scheme
+
+let validate_importmap s =
+  match parse_json s with
+  | Error msg -> [InvalidJSON msg]
+  | Ok json ->
+    let errors = ref [] in
+    let add_error e = errors := e :: !errors in
+
+    (match json with
+    | JObject members ->
+      List.iter (fun (key, value) ->
+        (* Check for forbidden top-level properties *)
+        if key <> "imports" && key <> "scopes" && key <> "integrity" then
+          add_error (ForbiddenProperty key);
+
+        (* Check imports *)
+        if key = "imports" then begin
+          match value with
+          | JObject import_members ->
+            List.iter (fun (ikey, ivalue) ->
+              if ikey = "" then add_error (EmptyKey "imports");
+              (* Check slash-ending consistency *)
+              let key_ends_with_slash = String.length ikey > 0 && ikey.[String.length ikey - 1] = '/' in
+              match ivalue with
+              | JString v ->
+                if key_ends_with_slash then begin
+                  let val_ends_with_slash = String.length v > 0 && v.[String.length v - 1] = '/' in
+                  if not val_ends_with_slash then
+                    add_error (SlashKeyWithoutSlashValue "imports")
+                end
+              | JNull -> ()  (* null is allowed *)
+              | _ -> add_error (NotString ("imports[" ^ ikey ^ "]"))
+            ) import_members
+          | _ -> add_error (NotObject "imports")
+        end;
+
+        (* Check scopes *)
+        if key = "scopes" then begin
+          match value with
+          | JObject scope_members ->
+            List.iter (fun (skey, svalue) ->
+              if skey = "" then add_error (EmptyKey "scopes");
+              (* Check that scope key is a valid URL *)
+              if skey <> "" && not (is_valid_url_like skey) then
+                add_error InvalidScopeKey;
+              match svalue with
+              | JObject scope_imports ->
+                List.iter (fun (sikey, sivalue) ->
+                  if sikey = "" then add_error (EmptyKey ("scopes[" ^ skey ^ "]"));
+                  match sivalue with
+                  | JString v ->
+                    (* Check that scope value is a valid URL *)
+                    if not (is_valid_url_like v) then
+                      add_error (InvalidScopeValue sikey)
+                  | JNull -> ()
+                  | _ -> add_error (NotString ("scopes[" ^ skey ^ "][" ^ sikey ^ "]"))
+                ) scope_imports
+              | _ -> add_error (NotObject ("scopes[" ^ skey ^ "]"))
+            ) scope_members
+          | _ -> add_error (NotObject "scopes")
+        end
+      ) members
+    | _ -> add_error (NotObject "root"));
+
+    List.rev !errors
+
+let start_element state ~name ~namespace ~attrs _collector =
+  if namespace <> None then ()
+  else begin
+    let name_lower = String.lowercase_ascii name in
+    if name_lower = "script" then begin
+      (* Check if type="importmap" *)
+      let type_attr = List.find_opt (fun (n, _) ->
+        String.lowercase_ascii n = "type"
+      ) attrs in
+      match type_attr with
+      | Some (_, v) when String.lowercase_ascii v = "importmap" ->
+        state.in_importmap <- true;
+        Buffer.clear state.content
+      | _ -> ()
+    end
+  end
+
+let error_to_message = function
+  | InvalidJSON _ ->
+    "A script \xe2\x80\x9cscript\xe2\x80\x9d with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must have valid JSON content."
+  | EmptyKey prop ->
+    Printf.sprintf "A specifier map defined in a \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must only contain non-empty keys." prop
+  | NotObject prop ->
+    Printf.sprintf "The value of the \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must be a JSON object." prop
+  | NotString _ ->
+    "A specifier map defined in a \xe2\x80\x9cimports\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must only contain string values."
+  | ForbiddenProperty prop ->
+    Printf.sprintf "The \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d is not an allowed property." prop
+  | SlashKeyWithoutSlashValue prop ->
+    Printf.sprintf "A specifier map defined in a \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must have values that end with \xe2\x80\x9c/\xe2\x80\x9d when its corresponding key ends with \xe2\x80\x9c/\xe2\x80\x9d." prop
+  | InvalidScopeKey ->
+    "The value of the \xe2\x80\x9cscopes\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must be a JSON object whose keys are valid URL strings."
+  | InvalidScopeValue _ ->
+    "A specifier map defined in a \xe2\x80\x9cscopes\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must only contain valid URL values."
+
+let end_element state ~name ~namespace collector =
+  if namespace <> None then ()
+  else begin
+    let name_lower = String.lowercase_ascii name in
+    if name_lower = "script" && state.in_importmap then begin
+      let content = Buffer.contents state.content in
+      let errors = validate_importmap content in
+      List.iter (fun err ->
+        Message_collector.add_error collector
+          ~message:(error_to_message err)
+          ~code:"importmap-invalid"
+          ~element:"script"
+          ~attribute:"type"
+          ()
+      ) errors;
+      state.in_importmap <- false
+    end
+  end
+
+let characters state text _collector =
+  if state.in_importmap then
+    Buffer.add_string state.content text
+
+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/importmap_checker.mli

···
+(** Importmap validation checker.
+
+    Validates that <script type="importmap"> elements contain valid JSON. *)
+
+val checker : Checker.t

lib/html5_checker/specialized/microdata_checker.ml

···
 let is_url s =
   String.contains s ':'
 
-(** Validate that a URL is a valid absolute URL for itemtype.
-    itemtype must be an absolute URL per the HTML5 spec.
-    http/https URLs require :// but other schemes like mailto:, data:, javascript: don't. *)
-let validate_itemtype_url url =
-  let url = String.trim url in
-  if String.length url = 0 then
-    Error "itemtype must not be empty"
+(** Validate that a URL is a valid absolute URL for itemtype/itemid.
+    Uses the comprehensive URL validation from Url_checker. *)
+let validate_microdata_url url element attr_name =
+  let url_trimmed = String.trim url in
+  if String.length url_trimmed = 0 then
+    Some (Printf.sprintf
+      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: Must be non-empty."
+      url attr_name element)
   else
-    match String.index_opt url ':' with
-    | None -> Error "Expected a slash (\"/\")."
-    | Some colon_pos ->
-      if colon_pos = 0 then
-        Error "Expected a slash (\"/\")."
-      else
-        let scheme = String.lowercase_ascii (String.sub url 0 colon_pos) in
-        (* Schemes that require :// for itemtype validation
-           Note: The Nu validator only enforces :// for http, https, and ftp *)
-        let special_schemes = [
-          "http"; "https"; "ftp"
-        ] in
-        if List.mem scheme special_schemes then begin
-          if colon_pos + 2 >= String.length url then
-            Error "Expected a slash (\"/\")."
-          else if url.[colon_pos + 1] <> '/' || url.[colon_pos + 2] <> '/' then
-            Error "Expected a slash (\"/\")."
-          else
-            Ok ()
-        end else
-          (* Other schemes (mailto:, data:, javascript:, etc.) are valid as-is *)
-          Ok ()
+    (* First check if it has a scheme (required for absolute URL) *)
+    match Url_checker.extract_scheme url_trimmed with
+    | None ->
+      Some (Printf.sprintf
+        "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: The string \xe2\x80\x9c%s\xe2\x80\x9d is not an absolute URL."
+        url attr_name element url)
+    | Some _ ->
+      (* Has a scheme - do comprehensive URL validation *)
+      match Url_checker.validate_url url element attr_name with
+      | None -> None
+      | Some error_msg ->
+        (* Replace "Bad URL:" with "Bad absolute URL:" for microdata *)
+        let error_msg = Str.global_replace (Str.regexp "Bad URL:") "Bad absolute URL:" error_msg in
+        Some error_msg
 
 (** Check if itemprop value is valid. *)
 let validate_itemprop_value value =
···
   let itemref_opt = get_attr attrs "itemref" in
   let itemprop_opt = get_attr attrs "itemprop" in
 
-  (* Check itemid requires itemscope and itemtype *)
+  (* Check itemid requires itemscope and itemtype, and validate URL *)
   begin match itemid_opt with
-  | Some _itemid ->
+  | Some itemid ->
       if not has_itemscope then
         Message_collector.add_error collector
           ~message:"itemid attribute requires itemscope attribute"
···
           ?location
           ~element
           ~attribute:"itemid"
-          ()
+          ();
+      (* Validate itemid as URL (note: itemid can be relative, unlike itemtype) *)
+      (match Url_checker.validate_url itemid element "itemid" with
+      | None -> ()
+      | Some error_msg ->
+        Message_collector.add_error collector
+          ~message:error_msg
+          ~code:"microdata-invalid-itemid"
+          ?location
+          ~element
+          ~attribute:"itemid"
+          ())
   | None -> ()
   end;
 
···
       else begin
         (* Validate each itemtype URL (can be space-separated) *)
         let types = split_whitespace itemtype in
-        List.iter (fun url ->
-          match validate_itemtype_url url with
-          | Ok () -> ()
-          | Error msg ->
-            Message_collector.add_error collector
-              ~message:(Printf.sprintf
-                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9citemtype\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: %s"
-                url element msg)
-              ~code:"microdata-invalid-itemtype"
-              ?location
-              ~element
-              ~attribute:"itemtype"
-              ()
-        ) types
+        if types = [] then
+          (* Empty itemtype is an error *)
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf
+              "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9citemtype\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d."
+              itemtype element)
+            ~code:"microdata-invalid-itemtype"
+            ?location
+            ~element
+            ~attribute:"itemtype"
+            ()
+        else
+          List.iter (fun url ->
+            match validate_microdata_url url element "itemtype" with
+            | None -> ()
+            | Some error_msg ->
+              Message_collector.add_error collector
+                ~message:error_msg
+                ~code:"microdata-invalid-itemtype"
+                ?location
+                ~element
+                ~attribute:"itemtype"
+                ()
+          ) types
       end
   | None -> ()
   end;

lib/html5_checker/specialized/mime_type_checker.ml

···
+(** MIME type validation checker.
+
+    Validates MIME type values in type attributes. *)
+
+(** Validate a MIME type value. Returns error message or None. *)
+let validate_mime_type value element attr_name =
+  let len = String.length value in
+  if len = 0 then
+    Some (Printf.sprintf
+      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Empty value."
+      value attr_name element)
+  else if value.[len - 1] = ' ' || value.[len - 1] = '\t' then
+    Some (Printf.sprintf
+      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Extraneous trailing whitespace."
+      value attr_name element)
+  else if len > 0 && (value.[0] = ' ' || value.[0] = '\t') then
+    Some (Printf.sprintf
+      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Expected a token character but saw \xe2\x80\x9c \xe2\x80\x9d instead."
+      value attr_name element)
+  else
+    (* Parse type/subtype *)
+    let slash_pos = try Some (String.index value '/') with Not_found -> None in
+    match slash_pos with
+    | None ->
+      (* No slash found - check if it looks like a type without subtype *)
+      let semicolon_pos = try Some (String.index value ';') with Not_found -> None in
+      (match semicolon_pos with
+      | Some _ ->
+        Some (Printf.sprintf
+          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Subtype missing."
+          value attr_name element)
+      | None ->
+        Some (Printf.sprintf
+          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Subtype missing."
+          value attr_name element))
+    | Some slash_pos ->
+      (* Check for empty subtype *)
+      let after_slash = String.sub value (slash_pos + 1) (len - slash_pos - 1) in
+      let subtype_end =
+        try String.index after_slash ';'
+        with Not_found -> String.length after_slash
+      in
+      let subtype = String.sub after_slash 0 subtype_end in
+      let subtype_trimmed = String.trim subtype in
+      if subtype_trimmed = "" then
+        Some (Printf.sprintf
+          "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Subtype missing."
+          value attr_name element)
+      else if String.length subtype > 0 && subtype.[String.length subtype - 1] = ' ' then
+        (* Space before semicolon - also check parameter format *)
+        let semicolon_pos = try Some (String.index value ';') with Not_found -> None in
+        (match semicolon_pos with
+        | Some semi_pos ->
+          (* Check what comes after semicolon *)
+          let params = String.sub value (semi_pos + 1) (len - semi_pos - 1) in
+          let params_trimmed = String.trim params in
+          if params_trimmed = "" then
+            Some (Printf.sprintf
+              "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Semicolon seen but there was no parameter following it."
+              value attr_name element)
+          else
+            (* Check for param_name=value format *)
+            let eq_pos = try Some (String.index params '=') with Not_found -> None in
+            (match eq_pos with
+            | None ->
+              Some (Printf.sprintf
+                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Parameter value missing."
+                value attr_name element)
+            | Some _ -> None)
+        | None -> None)
+      else
+        (* Check parameters after semicolon *)
+        let semicolon_pos = try Some (String.index value ';') with Not_found -> None in
+        (match semicolon_pos with
+        | None -> None  (* No parameters - OK *)
+        | Some semi_pos ->
+          let params = String.sub value (semi_pos + 1) (len - semi_pos - 1) in
+          let params_trimmed = String.trim params in
+          if params_trimmed = "" then
+            Some (Printf.sprintf
+              "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Semicolon seen but there was no parameter following it."
+              value attr_name element)
+          else
+            (* Check for param_name=value format *)
+            let eq_pos = try Some (String.index params '=') with Not_found -> None in
+            (match eq_pos with
+            | None ->
+              Some (Printf.sprintf
+                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Parameter value missing."
+                value attr_name element)
+            | Some eq_pos ->
+              let param_value = String.sub params (eq_pos + 1) (String.length params - eq_pos - 1) in
+              let param_value_trimmed = String.trim param_value in
+              if param_value_trimmed = "" then
+                Some (Printf.sprintf
+                  "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Parameter value missing."
+                  value attr_name element)
+              else if param_value_trimmed.[0] = '"' then
+                (* Quoted string - check for closing quote *)
+                let quote_end = try Some (String.index_from param_value_trimmed 1 '"') with
+                  | Not_found -> None
+                  | Invalid_argument _ -> None
+                in
+                (match quote_end with
+                | Some _ -> None  (* Properly quoted *)
+                | None ->
+                  (* Check for escaped quote at end *)
+                  let has_backslash_at_end =
+                    String.length param_value_trimmed >= 2 &&
+                    param_value_trimmed.[String.length param_value_trimmed - 1] = '\\'
+                  in
+                  if has_backslash_at_end then
+                    Some (Printf.sprintf
+                      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Unfinished quoted string."
+                      value attr_name element)
+                  else
+                    Some (Printf.sprintf
+                      "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad MIME type: Unfinished quoted string."
+                      value attr_name element))
+              else
+                None))
+
+(** Elements and attributes that contain MIME types. *)
+let mime_type_attrs = [
+  ("link", ["type"]);
+  ("style", ["type"]);
+  ("script", ["type"]);
+  ("source", ["type"]);
+  ("embed", ["type"]);
+  ("object", ["type"]);
+]
+
+type state = unit
+
+let create () = ()
+let reset _state = ()
+
+let get_attr_value name attrs =
+  List.find_map (fun (k, v) ->
+    if String.lowercase_ascii k = String.lowercase_ascii name then Some v else None
+  ) attrs
+
+let start_element _state ~name ~namespace ~attrs collector =
+  if namespace <> None then ()
+  else begin
+    let name_lower = String.lowercase_ascii name in
+    match List.assoc_opt name_lower mime_type_attrs with
+    | None -> ()
+    | Some type_attrs ->
+      List.iter (fun attr_name ->
+        match get_attr_value attr_name attrs with
+        | None -> ()
+        | Some value ->
+          (* Don't validate empty type attributes or special script types *)
+          if value = "" then ()
+          else if name_lower = "script" then
+            (* script type can be module, importmap, etc. - skip validation for non-MIME types *)
+            let value_lower = String.lowercase_ascii value in
+            if value_lower = "module" || value_lower = "importmap" ||
+               not (String.contains value '/') then ()
+            else
+              match validate_mime_type value name attr_name with
+              | None -> ()
+              | Some err ->
+                Message_collector.add_error collector
+                  ~message:err ~code:"bad-mime-type" ~element:name ~attribute:attr_name ()
+          else
+            match validate_mime_type value name attr_name with
+            | None -> ()
+            | Some err ->
+              Message_collector.add_error collector
+                ~message:err ~code:"bad-mime-type" ~element:name ~attribute:attr_name ()
+      ) type_attrs
+  end
+
+let end_element _state ~name:_ ~namespace:_ _collector = ()
+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/mime_type_checker.mli

···
+(** MIME type validation checker.
+
+    Validates MIME type values in type attributes. *)
+
+val checker : Checker.t

lib/html5_checker/specialized/table_checker.ml

···
 
 let reset state = state.tables := []
 
+let is_html_namespace = function
+  | None -> true  (* HTML mode - no namespace specified *)
+  | Some ns -> ns = html_ns  (* XHTML mode - check namespace *)
+
 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
-              | _ -> ())))
-  | _ -> ()
+  if is_html_namespace namespace then (
+    let name_lower = String.lowercase_ascii name in
+    match name_lower with
+    | "table" ->
+        (* Push a new table onto the stack *)
+        state.tables := make_table () :: !(state.tables)
+    | _ -> (
+        match !(state.tables) with
+        | [] -> ()
+        | table :: _ -> (
+            match name_lower 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
-              | _ -> ())))
-  | _ -> ()
+  if is_html_namespace namespace then (
+    let name_lower = String.lowercase_ascii name in
+    match name_lower with
+    | "table" -> (
+        match !(state.tables) with
+        | [] -> ()  (* End tag without start - ignore *)
+        | table :: rest ->
+            end_table table collector;
+            state.tables := rest)
+    | _ -> (
+        match !(state.tables) with
+        | [] -> ()
+        | table :: _ -> (
+            match name_lower 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 = ()
 

test/debug_check.ml

···
 let () =
-  let test_file = "validator/tests/html/microdata/itemtype/scheme-https-no-slash-novalid.html" in
+  let test_file = "validator/tests/html/mime-types/004-novalid.html" in
   let ic = open_in test_file in
   let html = really_input_string ic (in_channel_length ic) in
   close_in ic;