more

lib/html5_checker/checker_registry.ml

···
   Hashtbl.replace reg "label" Label_checker.checker;
   Hashtbl.replace reg "ruby" Ruby_checker.checker;
   Hashtbl.replace reg "h1" H1_checker.checker;
+  Hashtbl.replace reg "srcset-sizes" Srcset_sizes_checker.checker;
   (* Hashtbl.replace reg "table" Table_checker.checker; *)
   (* Hashtbl.replace reg "heading" Heading_checker.checker; *)
   (* Hashtbl.replace reg "microdata" Microdata_checker.checker; *)

lib/html5_checker/specialized/picture_checker.ml

···
   mutable children_in_picture : string list;
   mutable last_was_img : bool;
   mutable has_source_after_img : bool;
+  mutable has_always_matching_source : bool;  (* source without media/type *)
+  mutable source_after_always_matching : bool; (* source after always-matching source *)
 }
 
 let create () = {
···
   children_in_picture = [];
   last_was_img = false;
   has_source_after_img = false;
+  has_always_matching_source = false;
+  source_after_always_matching = false;
 }
 
 let reset state =
···
   state.picture_depth <- 0;
   state.children_in_picture <- [];
   state.last_was_img <- false;
-  state.has_source_after_img <- false
+  state.has_source_after_img <- false;
+  state.has_always_matching_source <- false;
+  state.source_after_always_matching <- false
 
 (** Check if an attribute list contains a specific attribute. *)
 let has_attr name attrs =
···
       state.picture_depth <- 0;  (* Will be incremented to 1 at end of function *)
       state.children_in_picture <- [];
       state.last_was_img <- false;
-      state.has_source_after_img <- false
+      state.has_source_after_img <- false;
+      state.has_always_matching_source <- false;
+      state.source_after_always_matching <- false
 
     | "source" when state.in_picture && state.picture_depth = 1 ->
       check_source_attrs_in_picture attrs collector;
       state.children_in_picture <- "source" :: state.children_in_picture;
       if state.last_was_img then
-        state.has_source_after_img <- true
+        state.has_source_after_img <- true;
+      (* Check for always-matching source followed by another source *)
+      if state.has_always_matching_source then
+        state.source_after_always_matching <- true;
+      (* A source is "always matching" if it has:
+         - no media and no type attribute, OR
+         - media attribute with empty/whitespace-only value, OR
+         - media="all" (with optional whitespace) *)
+      let media_value = List.find_map (fun (attr_name, v) ->
+        if String.lowercase_ascii attr_name = "media" then Some v else None
+      ) attrs in
+      let has_type = has_attr "type" attrs in
+      let is_always_matching = match media_value with
+        | None -> not has_type  (* no media, check if no type either *)
+        | Some v ->
+          let trimmed = String.trim v in
+          trimmed = "" || String.lowercase_ascii trimmed = "all"
+      in
+      if is_always_matching then
+        state.has_always_matching_source <- true
 
     | "img" when state.in_picture && state.picture_depth = 1 ->
       check_img_attrs attrs collector;
···
       (* Check for source after img *)
       if state.has_source_after_img then
         report_disallowed_child "picture" "source" collector;
+      (* Check for source after always-matching source *)
+      if state.source_after_always_matching then
+        Message_collector.add_error collector
+          ~message:"A \xe2\x80\x9csource\xe2\x80\x9d element that matches all media types cannot be followed by another \xe2\x80\x9csource\xe2\x80\x9d element."
+          ~code:"always-matching-source"
+          ~element:"source" ();
 
       state.in_picture <- false
     end

lib/html5_checker/specialized/srcset_sizes_checker.ml

···
+(** Srcset and sizes attribute validation checker. *)
+
+(** Valid CSS length units for sizes attribute *)
+let valid_length_units = [
+  "em"; "ex"; "ch"; "rem"; "cap"; "ic";
+  "vw"; "svw"; "lvw"; "dvw"; "vh"; "svh"; "lvh"; "dvh";
+  "vi"; "svi"; "lvi"; "dvi"; "vb"; "svb"; "lvb"; "dvb";
+  "vmin"; "svmin"; "lvmin"; "dvmin"; "vmax"; "svmax"; "lvmax"; "dvmax";
+  "cm"; "mm"; "q"; "in"; "pc"; "pt"; "px"
+]
+
+type state = unit
+
+let create () = ()
+let reset _state = ()
+
+(** Get attribute value *)
+let get_attr name attrs =
+  List.find_map (fun (n, v) ->
+    if String.lowercase_ascii n = name then Some v else None
+  ) attrs
+
+(** Check if string contains only whitespace *)
+let is_whitespace_only s =
+  String.for_all (fun c -> c = ' ' || c = '\t' || c = '\n' || c = '\r') s
+
+(** Invalid units that are not CSS lengths but might be confused for them *)
+let invalid_size_units = [
+  "deg"; "grad"; "rad"; "turn";  (* angle units *)
+  "s"; "ms";                      (* time units *)
+  "hz"; "khz";                    (* frequency units *)
+  "dpi"; "dpcm"; "dppx";         (* resolution units *)
+  "%"                            (* percentage - not valid in sizes *)
+]
+
+(** Strip CSS comments from a value *)
+let strip_css_comments s =
+  let buf = Buffer.create (String.length s) in
+  let len = String.length s in
+  let i = ref 0 in
+  while !i < len do
+    if !i + 1 < len && s.[!i] = '/' && s.[!i + 1] = '*' then begin
+      (* Start of comment, find end *)
+      i := !i + 2;
+      while !i + 1 < len && not (s.[!i] = '*' && s.[!i + 1] = '/') do
+        incr i
+      done;
+      if !i + 1 < len then i := !i + 2
+    end else begin
+      Buffer.add_char buf s.[!i];
+      incr i
+    end
+  done;
+  Buffer.contents buf
+
+(** Check if a size value has a valid CSS length unit and non-negative value *)
+type size_check_result = Valid | InvalidUnit | NegativeValue
+
+let check_size_value size_value =
+  let trimmed = String.trim (strip_css_comments size_value) in
+  if trimmed = "" then InvalidUnit
+  else if trimmed = "auto" then Valid  (* "auto" is valid *)
+  else begin
+    let lower = String.lowercase_ascii trimmed in
+    (* Check for invalid units first *)
+    let has_invalid = List.exists (fun unit ->
+      let len = String.length unit in
+      String.length lower > len &&
+      String.sub lower (String.length lower - len) len = unit
+    ) invalid_size_units in
+    if has_invalid then InvalidUnit
+    else begin
+      (* Check for valid CSS length units *)
+      let has_valid_unit = List.exists (fun unit ->
+        let len = String.length unit in
+        String.length lower > len &&
+        String.sub lower (String.length lower - len) len = unit
+      ) valid_length_units in
+      if has_valid_unit then begin
+        (* Check if it's negative (starts with - but not -0) *)
+        if String.length trimmed > 0 && trimmed.[0] = '-' then begin
+          (* Check if it's -0 which is valid *)
+          let after_minus = String.sub trimmed 1 (String.length trimmed - 1) in
+          let after_minus_stripped = String.trim (strip_css_comments after_minus) in
+          try
+            let num_str = Str.global_replace (Str.regexp "[a-zA-Z]+$") "" after_minus_stripped in
+            let f = float_of_string num_str in
+            if f = 0.0 then Valid else NegativeValue
+          with _ -> NegativeValue
+        end else
+          Valid
+      end
+      (* Could be calc() or other CSS functions - allow those *)
+      else if String.contains trimmed '(' then Valid
+      else begin
+        (* Check if it's a zero value (0, -0, +0) - these are valid without units *)
+        let stripped =
+          let s = trimmed in
+          let s = if String.length s > 0 && (s.[0] = '+' || s.[0] = '-') then String.sub s 1 (String.length s - 1) else s in
+          s
+        in
+        (* Check if it's zero or a numeric value starting with 0 *)
+        try
+          let f = float_of_string stripped in
+          if f = 0.0 then Valid else InvalidUnit
+        with _ -> InvalidUnit
+      end
+    end
+  end
+
+let has_valid_size_unit size_value =
+  match check_size_value size_value with
+  | Valid -> true
+  | InvalidUnit | NegativeValue -> false
+
+(** Check if a sizes entry has a media condition (starts with '(') *)
+let has_media_condition entry =
+  let trimmed = String.trim entry in
+  String.length trimmed > 0 && trimmed.[0] = '('
+
+(** Extract the size value from a sizes entry (after media condition if any) *)
+let extract_size_value entry =
+  let trimmed = String.trim entry in
+  if not (has_media_condition trimmed) then
+    trimmed
+  else begin
+    (* Find matching closing paren, then get the size value after it *)
+    let len = String.length trimmed in
+    let rec find_close_paren i depth =
+      if i >= len then len
+      else match trimmed.[i] with
+        | '(' -> find_close_paren (i + 1) (depth + 1)
+        | ')' -> if depth = 1 then i + 1 else find_close_paren (i + 1) (depth - 1)
+        | _ -> find_close_paren (i + 1) depth
+    in
+    let after_paren = find_close_paren 0 0 in
+    if after_paren >= len then ""
+    else String.trim (String.sub trimmed after_paren (len - after_paren))
+  end
+
+(** Validate sizes attribute value *)
+let validate_sizes value element_name collector =
+  (* Empty sizes is invalid *)
+  if String.trim value = "" then begin
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "Bad value \xe2\x80\x9c\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Must not be empty." element_name)
+      ~code:"bad-sizes-value"
+      ~element:element_name ~attribute:"sizes" ();
+    false
+  end else begin
+    (* Split on comma and check each entry *)
+    let entries = String.split_on_char ',' value in
+    let first_entry = String.trim (List.hd entries) in
+
+    (* Check if starts with comma (empty first entry) *)
+    if first_entry = "" then begin
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Starts with empty source size." value element_name)
+        ~code:"bad-sizes-value"
+        ~element:element_name ~attribute:"sizes" ();
+      false
+    end else begin
+      (* Check for trailing comma *)
+      let last_entry = String.trim (List.nth entries (List.length entries - 1)) in
+      if List.length entries > 1 && last_entry = "" then begin
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Ends with trailing comma." value element_name)
+          ~code:"bad-sizes-value"
+          ~element:element_name ~attribute:"sizes" ();
+        false
+      end else begin
+        let valid = ref true in
+
+        (* Check for default-first pattern: unconditional value before conditional ones *)
+        let non_empty_entries = List.filter (fun e -> String.trim e <> "") entries in
+        if List.length non_empty_entries > 1 then begin
+          let first = List.hd non_empty_entries in
+          let rest = List.tl non_empty_entries in
+          (* If first entry has no media condition but later ones do, that's invalid *)
+          if not (has_media_condition first) && List.exists has_media_condition rest then begin
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Default size must be last." value element_name)
+              ~code:"bad-sizes-value"
+              ~element:element_name ~attribute:"sizes" ();
+            valid := false
+          end
+        end;
+
+        (* Validate each entry's size value has valid unit and is not negative *)
+        List.iter (fun entry ->
+          let trimmed = String.trim entry in
+          if trimmed <> "" then begin
+            let size_val = extract_size_value trimmed in
+            if size_val <> "" then begin
+              match check_size_value size_val with
+              | Valid -> ()
+              | NegativeValue ->
+                Message_collector.add_error collector
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Source size value cannot be negative." value element_name)
+                  ~code:"bad-sizes-value"
+                  ~element:element_name ~attribute:"sizes" ();
+                valid := false
+              | InvalidUnit ->
+                Message_collector.add_error collector
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size value." value element_name)
+                  ~code:"bad-sizes-value"
+                  ~element:element_name ~attribute:"sizes" ();
+                valid := false
+            end
+          end
+        ) entries;
+
+        !valid
+      end
+    end
+  end
+
+(** Validate srcset descriptor *)
+let validate_srcset_descriptor desc element_name srcset_value collector =
+  let desc_lower = String.lowercase_ascii (String.trim desc) in
+  if String.length desc_lower = 0 then true
+  else begin
+    let last_char = desc_lower.[String.length desc_lower - 1] in
+    let num_part = String.sub desc_lower 0 (String.length desc_lower - 1) in
+
+    match last_char with
+    | 'w' ->
+      (* Width descriptor - must be positive integer *)
+      (try
+        let n = int_of_string num_part in
+        if n <= 0 then begin
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Width must be positive." srcset_value element_name)
+            ~code:"bad-srcset-value"
+            ~element:element_name ~attribute:"srcset" ();
+          false
+        end else begin
+          (* Check for uppercase W - compare original desc with lowercase version *)
+          let original_last = desc.[String.length desc - 1] in
+          if original_last = 'W' then begin
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Width descriptor must use lowercase \xe2\x80\x9cw\xe2\x80\x9d." srcset_value element_name)
+              ~code:"bad-srcset-value"
+              ~element:element_name ~attribute:"srcset" ();
+            false
+          end else true
+        end
+      with _ ->
+        (* Check for scientific notation or decimal *)
+        if String.contains num_part 'e' || String.contains num_part 'E' then begin
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Scientific notation not allowed in width descriptor." srcset_value element_name)
+            ~code:"bad-srcset-value"
+            ~element:element_name ~attribute:"srcset" ();
+          false
+        end else begin
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Invalid width descriptor." srcset_value element_name)
+            ~code:"bad-srcset-value"
+            ~element:element_name ~attribute:"srcset" ();
+          false
+        end)
+    | 'x' ->
+      (* Pixel density descriptor - must be positive number, no leading + *)
+      let trimmed_desc = String.trim desc in
+      if String.length trimmed_desc > 0 && trimmed_desc.[0] = '+' then begin
+        Message_collector.add_error collector
+          ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Leading plus sign not allowed." srcset_value element_name)
+          ~code:"bad-srcset-value"
+          ~element:element_name ~attribute:"srcset" ();
+        false
+      end else begin
+        (try
+          let n = float_of_string num_part in
+          if Float.is_nan n then begin
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: NaN not allowed." srcset_value element_name)
+              ~code:"bad-srcset-value"
+              ~element:element_name ~attribute:"srcset" ();
+            false
+          end else if n <= 0.0 then begin
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Density must be positive." srcset_value element_name)
+              ~code:"bad-srcset-value"
+              ~element:element_name ~attribute:"srcset" ();
+            false
+          end else if n = neg_infinity || n = infinity then begin
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Infinity not allowed." srcset_value element_name)
+              ~code:"bad-srcset-value"
+              ~element:element_name ~attribute:"srcset" ();
+            false
+          end else true
+        with _ ->
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Invalid density descriptor." srcset_value element_name)
+            ~code:"bad-srcset-value"
+            ~element:element_name ~attribute:"srcset" ();
+          false)
+      end
+    | 'h' ->
+      (* Height descriptor - not allowed *)
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Height descriptor \xe2\x80\x9ch\xe2\x80\x9d is not allowed." srcset_value element_name)
+        ~code:"bad-srcset-value"
+        ~element:element_name ~attribute:"srcset" ();
+      false
+    | _ ->
+      (* Unknown descriptor *)
+      Message_collector.add_error collector
+        ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor." srcset_value element_name)
+        ~code:"bad-srcset-value"
+        ~element:element_name ~attribute:"srcset" ();
+      false
+  end
+
+(** Normalize descriptor for duplicate detection (e.g., 1x = 1.0x) *)
+let normalize_descriptor desc =
+  let desc_lower = String.lowercase_ascii (String.trim desc) in
+  if String.length desc_lower = 0 then desc_lower
+  else
+    let last_char = desc_lower.[String.length desc_lower - 1] in
+    let num_part = String.sub desc_lower 0 (String.length desc_lower - 1) in
+    match last_char with
+    | 'x' ->
+      (* Normalize density to a float string for comparison *)
+      (try
+        let f = float_of_string num_part in
+        Printf.sprintf "%gx" f  (* %g removes trailing zeros *)
+      with _ -> desc_lower)
+    | 'w' ->
+      (* Width should be integer, just return as-is *)
+      desc_lower
+    | _ -> desc_lower
+
+(** Parse and validate srcset attribute value *)
+let validate_srcset value element_name has_sizes collector =
+  let entries = String.split_on_char ',' value in
+  let has_w_descriptor = ref false in
+  let has_x_descriptor = ref false in
+  let seen_descriptors = Hashtbl.create 8 in  (* Track seen descriptor values *)
+
+  (* Check for empty srcset *)
+  if String.trim value = "" then begin
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Must not be empty." value element_name)
+      ~code:"bad-srcset-value"
+      ~element:element_name ~attribute:"srcset" ()
+  end;
+
+  (* Check for leading comma *)
+  if String.length value > 0 && value.[0] = ',' then begin
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset: Leading comma." value element_name)
+      ~code:"bad-srcset-value"
+      ~element:element_name ~attribute:"srcset" ()
+  end;
+
+  (* Check for trailing comma *)
+  let trimmed_value = String.trim value in
+  if String.length trimmed_value > 0 && trimmed_value.[String.length trimmed_value - 1] = ',' then begin
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset: Trailing comma." value element_name)
+      ~code:"bad-srcset-value"
+      ~element:element_name ~attribute:"srcset" ()
+  end;
+
+  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
+      match parts with
+      | [] -> ()
+      | [_url] ->
+        (* URL only = implicit 1x descriptor - only flag if explicit 1x also seen *)
+        if Hashtbl.mem seen_descriptors "explicit-1x" then begin
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Duplicate descriptor." value element_name)
+            ~code:"bad-srcset-value"
+            ~element:element_name ~attribute:"srcset" ()
+        end else
+          Hashtbl.add seen_descriptors "implicit-1x" true
+      | _url :: desc :: rest ->
+        (* Check for extra junk - multiple descriptors are not allowed *)
+        if rest <> [] then begin
+          Message_collector.add_error collector
+            ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset: Multiple descriptors in candidate." value element_name)
+            ~code:"bad-srcset-value"
+            ~element:element_name ~attribute:"srcset" ()
+        end;
+
+        let desc_lower = String.lowercase_ascii (String.trim desc) in
+        if String.length desc_lower > 0 then begin
+          let last_char = desc_lower.[String.length desc_lower - 1] in
+          if last_char = 'w' then has_w_descriptor := true
+          else if last_char = 'x' then has_x_descriptor := true;
+
+          (* Check for duplicate descriptors - use normalized form *)
+          let normalized = normalize_descriptor desc in
+          let is_1x = (normalized = "1x") in
+          if Hashtbl.mem seen_descriptors normalized then begin
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Duplicate descriptor." value element_name)
+              ~code:"bad-srcset-value"
+              ~element:element_name ~attribute:"srcset" ()
+          end else if is_1x && Hashtbl.mem seen_descriptors "implicit-1x" then begin
+            (* Explicit 1x conflicts with implicit 1x *)
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Duplicate descriptor." value element_name)
+              ~code:"bad-srcset-value"
+              ~element:element_name ~attribute:"srcset" ()
+          end else begin
+            Hashtbl.add seen_descriptors normalized true;
+            if is_1x then Hashtbl.add seen_descriptors "explicit-1x" true
+          end
+        end;
+
+        ignore (validate_srcset_descriptor desc element_name value collector)
+    end
+  ) entries;
+
+  (* Check: if w descriptor used and no sizes, that's an error for img and source *)
+  if !has_w_descriptor && not has_sizes then
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "When the \xe2\x80\x9csrcset\xe2\x80\x9d attribute on the \xe2\x80\x9c%s\xe2\x80\x9d element uses width descriptors, the \xe2\x80\x9csizes\xe2\x80\x9d attribute must also be present." element_name)
+      ~code:"srcset-w-without-sizes"
+      ~element:element_name ~attribute:"srcset" ();
+
+  (* Check for mixing w and x descriptors *)
+  if !has_w_descriptor && !has_x_descriptor then
+    Message_collector.add_error collector
+      ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Mixing width and density descriptors is not allowed." value element_name)
+      ~code:"bad-srcset-value"
+      ~element:element_name ~attribute:"srcset" ()
+
+let start_element _state ~name ~namespace ~attrs collector =
+  if namespace <> None then ()
+  else begin
+    let name_lower = String.lowercase_ascii name in
+
+    (* Check sizes and srcset on img and source *)
+    if name_lower = "img" || name_lower = "source" then begin
+      let sizes_value = get_attr "sizes" attrs in
+      let srcset_value = get_attr "srcset" attrs in
+      let has_sizes = sizes_value <> None in
+
+      (* Validate sizes if present *)
+      (match sizes_value with
+       | Some v -> ignore (validate_sizes v name_lower collector)
+       | None -> ());
+
+      (* Validate srcset if present *)
+      (match srcset_value with
+       | Some v -> validate_srcset v name_lower has_sizes collector
+       | None -> ())
+    end
+  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)