fix

lib/html5_checker/datatype/dt_media_query.ml

···
   let color_features = ["color"; "min-color"; "max-color"; "color-index"; "min-color-index"; "max-color-index";
                         "monochrome"; "min-monochrome"; "max-monochrome"] in
 
+  (* Get base feature name for error messages (strip min-/max- prefix) *)
+  let base_feature =
+    if String.length feature > 4 && String.sub feature 0 4 = "min-" then
+      String.sub feature 4 (String.length feature - 4)
+    else if String.length feature > 4 && String.sub feature 0 4 = "max-" then
+      String.sub feature 4 (String.length feature - 4)
+    else
+      feature
+  in
+
   if List.mem feature length_features then begin
     (* Must be a valid length: number followed by unit *)
     let value = String.trim value in
···
       let unit_lower = String.lowercase_ascii unit_part in
       if List.mem unit_lower valid_length_units then Ok ()
       else if List.mem unit_lower valid_resolution_units then
-        Error (Printf.sprintf "\"%s\" is not a \"%s\" value" value feature)
+        Error (Printf.sprintf "\"%s\" is not a \"%s\" value" value base_feature)
       else
         Error "Unknown dimension."
     end
···
     let is_digit c = c >= '0' && c <= '9' in
     if String.length value > 0 && String.for_all is_digit value then Ok ()
     else
-      Error (Printf.sprintf "\"%s\" is not a \"%s\" value" value feature)
+      Error (Printf.sprintf "\"%s\" is not a \"%s\" value" value base_feature)
   end else
     Ok () (* Allow other features with any value for now *)
 

lib/html5_checker/parse_error_bridge.ml

···
           else if String.length s > 19 && String.sub s 0 19 = "unexpected-end-tag:" then
             let element = String.sub s 19 (String.length s - 19) in
             (Printf.sprintf "Stray end tag \xe2\x80\x9c%s\xe2\x80\x9d." element, "stray-end-tag")
+          else if String.length s > 19 && String.sub s 0 19 = "start-tag-in-table:" then
+            let tag = String.sub s 19 (String.length s - 19) in
+            (Printf.sprintf "Start tag \xe2\x80\x9c%s\xe2\x80\x9d seen in \xe2\x80\x9ctable\xe2\x80\x9d." tag, "start-tag-in-table")
           else
             (Printf.sprintf "Parse error: %s" s, s)
         with _ -> (Printf.sprintf "Parse error: %s" s, s))

lib/html5_checker/semantic/id_checker.ml

···
       (* Use specific error for list attribute on input *)
       if ref.attribute = "list" && ref.referring_element = "input" then
         Message_collector.add_typed collector Error_code.List_attr_requires_datalist
+      else if ref.attribute = "commandfor" then
+        (* commandfor has a specific expected message format *)
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf "The value of the %s attribute of the %s element must be the ID of an element in the same tree as the %s with the %s attribute."
+            (Error_code.q "commandfor") (Error_code.q ref.referring_element)
+            (Error_code.q ref.referring_element) (Error_code.q "commandfor"))
+          ~code:"dangling-id-reference"
+          ~element:ref.referring_element
+          ~attribute:ref.attribute
+          ()
       else
         (* Use generic for dangling references - format may vary *)
         Message_collector.add_typed collector

lib/html5_checker/semantic/option_checker.ml

···
   ) attrs
 
 let start_element state ~name ~namespace ~attrs collector =
-  ignore collector;
   let name_lower = String.lowercase_ascii name in
 
   if namespace <> None then ()
···
         | Some v -> String.trim v = ""
         | None -> false
       in
+      (* Report error for empty label attribute value *)
+      if label_empty then
+        Message_collector.add_error collector
+          ~message:"Bad value \xe2\x80\x9c\xe2\x80\x9d for attribute \xe2\x80\x9clabel\xe2\x80\x9d on element \xe2\x80\x9coption\xe2\x80\x9d: Bad non-empty string: Must not be empty."
+          ~code:"empty-attribute-value"
+          ~element:"option"
+          ~attribute:"label"
+          ();
       let ctx = { has_text = false; has_label; label_empty } in
       state.option_stack <- ctx :: state.option_stack
     end
···
       | ctx :: rest ->
         state.option_stack <- rest;
         (* Validate: option must have text content or non-empty label *)
-        if not ctx.has_text then begin
-          if ctx.label_empty || not ctx.has_label then
-            (* Has label="" (empty) and no text, or no label at all - error *)
-            Message_collector.add_typed collector Error_code.Option_empty_without_label
-        end
+        (* Note: empty label error is already reported at start_element,
+           so only report empty option without label when there's no label attribute at all *)
+        if not ctx.has_text && not ctx.has_label then
+          Message_collector.add_typed collector Error_code.Option_empty_without_label
       | [] -> ()
     end
   end

lib/html5_checker/specialized/aria_checker.ml

···
     (* Window roles *)
     "alertdialog";
 
-    (* Abstract roles - not for use in HTML content *)
-    "command"; "comment"; "composite"; "input"; "landmark"; "range";
-    "roletype"; "section"; "sectionhead"; "select"; "structure"; "widget";
-    "window";
+    (* Note: Abstract roles (command, composite, input, landmark, range, etc.)
+       are NOT included as they should not be used in HTML content.
+       Using an abstract role will result in "Discarding unrecognized token" error. *)
 
     (* Additional roles *)
     "application"; "columnheader"; "rowheader";
···
         end
     | None -> Some "textbox" (* default input type is text *)
   end
+  (* Check for area element - implicit role depends on href attribute *)
+  else if element_name = "area" then begin
+    match List.assoc_opt "href" attrs with
+    | Some _ -> Some "link"  (* area with href has implicit role "link" *)
+    | None -> Some "generic" (* area without href has no corresponding role, treated as generic *)
+  end
+  (* Check for a element - implicit role depends on href attribute *)
+  else if element_name = "a" then begin
+    match List.assoc_opt "href" attrs with
+    | Some _ -> Some "link"  (* a with href has implicit role "link" *)
+    | None -> Some "generic" (* a without href has no corresponding role, treated as generic *)
+  end
   else
     Hashtbl.find_opt elements_with_implicit_role element_name
 
···
         | Some role_value -> split_roles role_value
         | None -> []
       in
+
+      (* Check for unrecognized role tokens *)
+      List.iter (fun role ->
+        if not (Hashtbl.mem valid_aria_roles role) then
+          Message_collector.add_typed collector
+            (Error_code.Discarding_unrecognized_role { token = role })
+      ) explicit_roles;
 
       (* Get implicit role for this element *)
       let implicit_role = get_implicit_role name_lower attrs in

lib/html5_checker/specialized/attr_restrictions_checker.ml

···
         (* Check if the name contains colon - not XML serializable *)
         else if String.contains after_prefix ':' then
           Message_collector.add_error collector
-            ~message:(Printf.sprintf "Attribute \xe2\x80\x9c%s\xe2\x80\x9d is not serializable as XML 1.0."
-              attr_name)
+            ~message:"\xe2\x80\x9cdata-*\xe2\x80\x9d attribute names must be XML 1.0 4th ed. plus Namespaces NCNames."
             ~code:"bad-attribute-name"
             ~element:name ~attribute:attr_name ()
       end
···
 
     if has_command && has_aria_expanded then
       Message_collector.add_error collector
-        ~message:"The \xe2\x80\x9caria-expanded\xe2\x80\x9d attribute must not be specified on \xe2\x80\x9cbutton\xe2\x80\x9d elements that have the \xe2\x80\x9ccommand\xe2\x80\x9d attribute."
+        ~message:"The \xe2\x80\x9caria-expanded\xe2\x80\x9d attribute must not be used on any element which has a \xe2\x80\x9ccommand\xe2\x80\x9d attribute."
         ~code:"disallowed-attribute"
         ~element:name ~attribute:"aria-expanded" ();
 
     if has_popovertarget && has_aria_expanded then
       Message_collector.add_error collector
-        ~message:"The \xe2\x80\x9caria-expanded\xe2\x80\x9d attribute must not be specified on \xe2\x80\x9cbutton\xe2\x80\x9d elements that have the \xe2\x80\x9cpopovertarget\xe2\x80\x9d attribute."
+        ~message:"The \xe2\x80\x9caria-expanded\xe2\x80\x9d attribute must not be used on any element which has a \xe2\x80\x9cpopovertarget\xe2\x80\x9d attribute."
         ~code:"disallowed-attribute"
         ~element:name ~attribute:"aria-expanded" ()
   end;

lib/html5_checker/specialized/mime_type_checker.ml

···
     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 value.[len - 1] = ' ' || value.[len - 1] = '\t' then begin
+    (* Check if this is a semicolon followed by only whitespace *)
+    let semicolon_pos = try Some (String.index value ';') with Not_found -> None in
+    match semicolon_pos with
+    | 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
+        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)
+    | 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: Extraneous trailing whitespace."
+        value attr_name element)
+  end
   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."

lib/html5_checker/specialized/srcset_sizes_checker.ml

···
     if String.lowercase_ascii n = name then Some v else None
   ) attrs
 
+(** Split string on a character while respecting parentheses *)
+let split_respecting_parens ~sep s =
+  let len = String.length s in
+  let result = ref [] in
+  let current = Buffer.create 64 in
+  let depth = ref 0 in
+  for i = 0 to len - 1 do
+    let c = s.[i] in
+    if c = '(' then begin
+      incr depth;
+      Buffer.add_char current c
+    end else if c = ')' then begin
+      decr depth;
+      Buffer.add_char current c
+    end else if c = sep && !depth = 0 then begin
+      result := Buffer.contents current :: !result;
+      Buffer.clear current
+    end else
+      Buffer.add_char current c
+  done;
+  (* Add the last segment *)
+  result := Buffer.contents current :: !result;
+  List.rev !result
+
+(** Split string on commas while respecting parentheses *)
+let split_on_comma_respecting_parens s = split_respecting_parens ~sep:',' s
+
+(** Split string on spaces while respecting parentheses, filtering empty segments *)
+let split_on_space_respecting_parens s =
+  split_respecting_parens ~sep:' ' s |> List.filter (fun s -> s <> "")
+
 (** Check if string contains only whitespace *)
 let is_whitespace_only s =
   String.for_all (fun c -> c = ' ' || c = '\t' || c = '\n' || c = '\r') s
···
 
 (** Parse and validate srcset attribute value *)
 let validate_srcset value element_name has_sizes collector =
-  let entries = String.split_on_char ',' value in
+  let entries = split_on_comma_respecting_parens value in
   let has_w_descriptor = ref false in
   let has_x_descriptor = ref false in
   let no_descriptor_url = ref None in  (* Track URL of first entry without width descriptor *)
···
   List.iter (fun entry ->
     let entry = String.trim entry in
     if entry <> "" then begin
-      (* Split entry into URL and optional descriptor *)
-      let parts = String.split_on_char ' ' entry |> List.filter (fun s -> s <> "") in
+      (* Split entry into URL and optional descriptor - respect parentheses *)
+      let parts = split_on_space_respecting_parens entry in
       (* Check if URL is valid *)
       let check_srcset_url url =
         (* Special schemes that require host/content after :// *)

lib/html5_checker/specialized/svg_checker.ml

···
 (* Validate xmlns attributes *)
 let validate_xmlns_attr attr value element collector =
   match attr with
-  | "xmlns" when element = "svg" ->
+  | "xmlns" ->
+      (* xmlns on any SVG element must be the SVG namespace *)
       if value <> svg_ns_url then
         Message_collector.add_error collector
           ~message:(Printf.sprintf
···
     let flag = Str.matched_group 4 d in
     if flag <> "0" && flag <> "1" then begin
       let pos = Str.match_beginning () in
-      let ctx_end = min (String.length d) (pos + 25) in
+      (* Context ends right after the invalid flag *)
+      let flag_end = Str.match_end () in
       let ctx_start = max 0 (pos - 10) in
-      let context = String.sub d ctx_start (ctx_end - ctx_start) in
+      let context = String.sub d ctx_start (flag_end - ctx_start) in
       Message_collector.add_error collector
         ~message:(Printf.sprintf
           "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9cd\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad SVG path data: Expected \xe2\x80\x9c0\xe2\x80\x9d or \xe2\x80\x9c1\xe2\x80\x9d for large-arc-flag for \xe2\x80\x9ca\xe2\x80\x9d command but found \xe2\x80\x9c%s\xe2\x80\x9d instead (context: \xe2\x80\x9c%s\xe2\x80\x9d)."
···
       | [] -> ()
     end;
 
+    (* 2.5 Check stop element is only in linearGradient or radialGradient *)
+    if name_lower = "stop" then begin
+      match state.element_stack with
+      | parent :: _ when (let p = String.lowercase_ascii parent in
+                          p = "lineargradient" || p = "radialgradient") -> ()
+      | parent :: _ ->
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf
+              "Element \xe2\x80\x9c%s\xe2\x80\x9d not allowed as child of element \xe2\x80\x9c%s\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
+              name parent)
+            ~element:name
+            ()
+      | [] -> ()
+    end;
+
+    (* 2.6 Check use element is not nested inside another use element *)
+    if name_lower = "use" then begin
+      match state.element_stack with
+      | parent :: _ when String.lowercase_ascii parent = "use" ->
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf
+              "Element \xe2\x80\x9c%s\xe2\x80\x9d not allowed as child of element \xe2\x80\x9c%s\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
+              name parent)
+            ~element:name
+            ()
+      | _ -> ()
+    end;
+
     (* 3. Check duplicate feFunc* in feComponentTransfer *)
     (match state.element_stack with
     | parent :: _ when String.lowercase_ascii parent = "fecomponenttransfer" ->
···
                 Message_collector.add_error collector
                   ~message:(Printf.sprintf
                     "Element \xe2\x80\x9c%s\xe2\x80\x9d not allowed as child of element \xe2\x80\x9cfeComponentTransfer\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
-                    name_lower)
-                  ~element:name_lower
+                    name)
+                  ~element:name
                   ()
               else
                 fect.seen_funcs <- name_lower :: fect.seen_funcs
···
         Message_collector.add_error collector
           ~message:(Printf.sprintf
             "Attribute \xe2\x80\x9c%s\xe2\x80\x9d not allowed on element \xe2\x80\x9c%s\xe2\x80\x9d at this point."
-            attr name_lower)
-          ~element:name_lower
+            attr name)
+          ~element:name
           ~attribute:attr_lower
           ()
       (* Validate path data *)
       else if attr_lower = "d" && name_lower = "path" then
-        validate_path_data value name_lower collector
+        validate_path_data value name collector
       (* Check if attribute is valid for this element *)
       else if not (is_valid_attr name_lower attr_lower) then
         Message_collector.add_error collector
           ~message:(Printf.sprintf
             "Attribute \xe2\x80\x9c%s\xe2\x80\x9d not allowed on element \xe2\x80\x9c%s\xe2\x80\x9d at this point."
-            attr name_lower)
-          ~element:name_lower
+            attr name)
+          ~element:name
           ~attribute:attr_lower
           ()
     ) attrs;

lib/html5rw/parser/parser_tree_builder.ml

···
   | Token.Tag { kind = Token.End; name; _ }
     when List.mem name ["address"; "article"; "aside"; "blockquote"; "button"; "center"; "details"; "dialog"; "dir"; "div"; "dl"; "fieldset"; "figcaption"; "figure"; "footer"; "header"; "hgroup"; "listing"; "main"; "menu"; "nav"; "ol"; "pre"; "search"; "section"; "summary"; "ul"] ->
     if not (has_element_in_scope t name) then
-      parse_error t "unexpected-end-tag"
+      parse_error t ("unexpected-end-tag:" ^ name)
     else begin
       generate_implied_end_tags t ();
       (match current_node t with
···
       String.lowercase_ascii k = "type" && String.lowercase_ascii v = "hidden"
     ) attrs in
     if not is_hidden then begin
-      parse_error t "unexpected-start-tag";
+      parse_error t "start-tag-in-table:input";
       t.foster_parenting <- true;
       process_in_body t token;
       t.foster_parenting <- false
     end else begin
-      parse_error t "unexpected-start-tag";
+      parse_error t "start-tag-in-table:input";
       ignore (insert_element t "input" ~push:true attrs);
       pop_current t
     end

test/test_nfc_debug.ml

···
+let () =
+  let content = In_channel.with_open_text "validator/tests/html-svg/struct-cond-02-t-haswarn.html" (fun ic ->
+    In_channel.input_all ic
+  ) in
+  let reader = Bytesrw.Bytes.Reader.of_string content in
+  let result = Html5_checker.check ~system_id:"test.html" reader in
+  let warnings = Html5_checker.warnings result in
+  Printf.printf "Total warnings: %d\n" (List.length warnings);
+  List.iter (fun msg ->
+    Printf.printf "WARNING: %s\n" (Html5_checker.Message.message msg)
+  ) warnings