more

lib/htmlrw_check/attr_utils.ml

···
+(** Common attribute utilities used across checkers. *)
+
+type attrs = (string * string) list
+
+let has_attr name attrs =
+  List.exists (fun (n, _) -> String.lowercase_ascii n = name) attrs
+
+let get_attr name attrs =
+  List.find_map (fun (n, v) ->
+    if String.lowercase_ascii n = name then Some v else None
+  ) attrs
+
+let get_attr_or name ~default attrs =
+  Option.value ~default (get_attr name attrs)
+
+let is_non_empty_attr name attrs =
+  match get_attr name attrs with
+  | Some v -> String.trim v <> ""
+  | None -> false

lib/htmlrw_check/datatype/dt_color.ml

···
     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
+    else if String.starts_with ~prefix:"rgb(" s || String.starts_with ~prefix:"rgba(" s 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
+    else if String.starts_with ~prefix:"hsl(" s || String.starts_with ~prefix:"hsla(" s 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 ')'"

lib/htmlrw_check/datatype/dt_media_query.ml

···
 
   (* 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
+    if String.starts_with ~prefix:"min-" feature then
       String.sub feature 4 (String.length feature - 4)
-    else if String.length feature > 4 && String.sub feature 0 4 = "max-" then
+    else if String.starts_with ~prefix:"max-" feature then
       String.sub feature 4 (String.length feature - 4)
     else
       feature

lib/htmlrw_check/message_format.ml

···
+(** Get effective system_id, preferring location's system_id over the passed one *)
+let get_system_id ?system_id loc_system_id =
+  loc_system_id
+  |> Option.fold ~none:system_id ~some:Option.some
+  |> Option.value ~default:"input"
+
 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 = " [" ^ Message.error_code_to_string msg.Message.error_code ^ "]" 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;
+  List.iter (fun msg ->
+    let loc_str = match msg.Message.location with
+      | Some loc ->
+        let sid = get_system_id ?system_id loc.Message.system_id 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 ->
+        Option.value system_id ~default:"input"
+    in
+    let elem_str = Option.fold ~none:"" ~some:(Printf.sprintf " (element: %s)") msg.Message.element in
+    let attr_str = Option.fold ~none:"" ~some:(Printf.sprintf " (attribute: %s)") msg.Message.attribute in
+    Buffer.add_string buf (Printf.sprintf "%s: %s [%s]: %s%s%s\n"
+      loc_str
+      (Message.severity_to_string msg.Message.severity)
+      (Message.error_code_to_string msg.Message.error_code)
+      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 = " [" ^ Message.error_code_to_string msg.Message.error_code ^ "]" in
-      Buffer.add_string buf
-        (Printf.sprintf "%s: %s%s: %s\n" loc_str severity_str code_str
-           msg.Message.message))
-    messages;
+  List.iter (fun msg ->
+    let loc_str = match msg.Message.location with
+      | Some loc ->
+        Printf.sprintf "%s:%d:%d"
+          (get_system_id ?system_id loc.Message.system_id)
+          loc.line loc.column
+      | None ->
+        Option.value system_id ~default:"input" ^ ":0:0"
+    in
+    Buffer.add_string buf (Printf.sprintf "%s: %s [%s]: %s\n"
+      loc_str
+      (Message.severity_to_string msg.Message.severity)
+      (Message.error_code_to_string msg.Message.error_code)
+      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 =
-    (("subType", Meta.none), String (Message.error_code_to_string msg.Message.error_code, Meta.none)) :: base
-  in
-  let with_location =
-    match msg.Message.location with
+  let str s = String (s, Meta.none) in
+  let num n = Number (float_of_int n, Meta.none) in
+  let field name value = ((name, Meta.none), value) in
+
+  let base = [
+    field "type" (str (Message.severity_to_string msg.Message.severity));
+    field "message" (str msg.Message.message);
+    field "subType" (str (Message.error_code_to_string msg.Message.error_code));
+  ] 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
+      let url = get_system_id ?system_id loc.Message.system_id in
+      let loc_fields = [
+        field "url" (str url);
+        field "firstLine" (num loc.line);
+        field "firstColumn" (num loc.column);
+      ] in
+      let loc_fields = Option.fold ~none:loc_fields
+        ~some:(fun el -> field "lastLine" (num el) :: loc_fields)
+        loc.Message.end_line in
+      let loc_fields = Option.fold ~none:loc_fields
+        ~some:(fun ec -> field "lastColumn" (num ec) :: loc_fields)
+        loc.Message.end_column in
+      loc_fields @ base
     | None ->
-        let url =
-          match system_id with Some s -> s | None -> "input"
-        in
-        (("url", Meta.none), String (url, Meta.none)) :: with_code
+      field "url" (str (Option.value system_id ~default:"input")) :: base
   in
-  let with_extract =
-    match msg.Message.extract with
-    | Some e -> (("extract", Meta.none), String (e, Meta.none)) :: with_location
-    | None -> with_location
-  in
+
+  let with_extract = Option.fold ~none:with_location
+    ~some:(fun e -> field "extract" (str e) :: with_location)
+    msg.Message.extract in
+
   Object (with_extract, Meta.none)
 
 let format_json ?system_id messages =

lib/htmlrw_check/parse_error_bridge.ml

···
   | Html5rw.Parse_error_code.Tree_construction_error s ->
       (* Check for control-character/noncharacter/surrogate with codepoint info *)
       (try
-        if String.length s > 28 && String.sub s 0 28 = "control-character-in-input-s" then
+        if String.starts_with ~prefix:"control-character-in-input-s" s then
           let colon_pos = String.index s ':' in
           let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
           let cp = int_of_string ("0x" ^ cp_str) in
           Printf.sprintf "Forbidden code point U+%04x." cp
-        else if String.length s > 25 && String.sub s 0 25 = "noncharacter-in-input-str" then
+        else if String.starts_with ~prefix:"noncharacter-in-input-str" s then
           let colon_pos = String.index s ':' in
           let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
           let cp = int_of_string ("0x" ^ cp_str) in
           Printf.sprintf "Forbidden code point U+%04x." cp
-        else if String.length s > 22 && String.sub s 0 22 = "surrogate-in-input-str" then
+        else if String.starts_with ~prefix:"surrogate-in-input-str" s then
           let colon_pos = String.index s ':' in
           let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
           let cp = int_of_string ("0x" ^ cp_str) in
           Printf.sprintf "Forbidden code point U+%04x." cp
         (* Character reference errors *)
-        else if String.length s > 28 && String.sub s 0 28 = "control-character-reference:" then
+        else if String.starts_with ~prefix:"control-character-reference:" s then
           let cp_str = String.sub s 28 (String.length s - 28) in
           let cp = int_of_string ("0x" ^ cp_str) in
           if cp = 0x0D then
             "A numeric character reference expanded to carriage return."
           else
             Printf.sprintf "Character reference expands to a control character (U+%04x)." cp
-        else if String.length s > 31 && String.sub s 0 31 = "noncharacter-character-referenc" then
+        else if String.starts_with ~prefix:"noncharacter-character-referenc" s then
           let colon_pos = String.index s ':' in
           let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
           let cp = int_of_string ("0x" ^ cp_str) in
···
             Printf.sprintf "Character reference expands to an astral non-character (U+%05x)." cp
           else
             Printf.sprintf "Character reference expands to a non-character (U+%04x)." cp
-        else if String.length s > 36 && String.sub s 0 36 = "character-reference-outside-unicode-" then
+        else if String.starts_with ~prefix:"character-reference-outside-unicode-" s then
           "Character reference outside the permissible Unicode range."
-        else if String.length s > 27 && String.sub s 0 27 = "surrogate-character-referen" then
+        else if String.starts_with ~prefix:"surrogate-character-referen" s then
           let colon_pos = String.index s ':' in
           let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
           let cp = int_of_string ("0x" ^ cp_str) in
···
           "End tag \xe2\x80\x9cbr\xe2\x80\x9d."
         else if s = "expected-closing-tag-but-got-eof" then
           "End of file seen and there were open elements."
-        else if String.length s > 28 && String.sub s 0 28 = "bad-start-tag-in-head-noscri" then
+        else if String.starts_with ~prefix:"bad-start-tag-in-head-noscri" s then
           let colon_pos = String.index s ':' in
           let element = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
           Printf.sprintf "Bad start tag in \xe2\x80\x9c%s\xe2\x80\x9d in \xe2\x80\x9cnoscript\xe2\x80\x9d in \xe2\x80\x9chead\xe2\x80\x9d." element
-        else if String.length s > 19 && String.sub s 0 19 = "unexpected-end-tag:" then
+        else if String.starts_with ~prefix:"unexpected-end-tag:" s 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
-        else if String.length s > 19 && String.sub s 0 19 = "start-tag-in-table:" then
+        else if String.starts_with ~prefix:"start-tag-in-table:" s 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
         else

lib/htmlrw_check/semantic/autofocus_checker.ml

···
     Validates that only one element with autofocus attribute exists within
     each dialog or popover context. *)
 
-(** Context for tracking autofocus elements. *)
 type context_type = Dialog | Popover
 
 type context = {
···
   state.context_stack <- [];
   state.current_depth <- 0
 
-(** Check if an attribute list contains a specific attribute. *)
-let has_attr name attrs =
-  List.exists (fun (attr_name, _) -> String.lowercase_ascii attr_name = name) attrs
-
-(** Get an attribute value from the list. *)
-let get_attr name attrs =
-  List.find_map (fun (attr_name, value) ->
-    if String.lowercase_ascii attr_name = name then Some value else None
-  ) attrs
-
-(** Check if element has popover attribute. *)
-let has_popover attrs =
-  List.exists (fun (attr_name, _) ->
-    String.lowercase_ascii attr_name = "popover"
-  ) attrs
-
 let start_element state ~name ~namespace ~attrs collector =
-  let name_lower = String.lowercase_ascii name in
-
-  (* Track depth *)
   state.current_depth <- state.current_depth + 1;
 
-  if namespace = None then begin
+  match namespace with
+  | Some _ -> ()
+  | None ->
+    let name_lower = String.lowercase_ascii name in
+
     (* Check if we're entering a dialog or popover context *)
-    let enters_context =
-      if name_lower = "dialog" then Some Dialog
-      else if has_popover attrs then Some Popover
-      else None
+    let enters_context = match name_lower with
+      | "dialog" -> Some Dialog
+      | _ when Attr_utils.has_attr "popover" attrs -> Some Popover
+      | _ -> None
     in
 
-    (match enters_context with
-    | Some ctx_type ->
+    Option.iter (fun ctx_type ->
       let ctx = { context_type = ctx_type; autofocus_count = 0; depth = state.current_depth } in
       state.context_stack <- ctx :: state.context_stack
-    | None -> ());
+    ) enters_context;
 
     (* Check for autofocus attribute *)
-    if has_attr "autofocus" attrs then begin
-      (* Increment count in innermost context if any *)
+    if Attr_utils.has_attr "autofocus" attrs then
       match state.context_stack with
       | ctx :: _ ->
         ctx.autofocus_count <- ctx.autofocus_count + 1;
         if ctx.autofocus_count > 1 then
           Message_collector.add_typed collector (`Misc `Multiple_autofocus)
       | [] -> ()
-    end
-  end
 
 let end_element state ~name ~namespace _collector =
-  let name_lower = String.lowercase_ascii name in
-
-  if namespace = None then begin
-    (* Pop context if we're leaving one *)
+  (match namespace with
+  | Some _ -> ()
+  | None ->
+    let name_lower = String.lowercase_ascii name in
     match state.context_stack with
     | ctx :: rest when ctx.depth = state.current_depth ->
-      (* Verify this is the right element *)
       let matches =
         (name_lower = "dialog" && ctx.context_type = Dialog) ||
         (ctx.context_type = Popover)
       in
       if matches then state.context_stack <- rest
-    | _ -> ()
-  end;
+    | _ -> ());
 
   state.current_depth <- state.current_depth - 1
 

lib/htmlrw_check/semantic/form_checker.ml

···
 
 let reset _state = ()
 
-(** 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 autocomplete value contains webauthn token *)
 let contains_webauthn value =
   let lower = String.lowercase_ascii value in
···
   (* Check autocomplete attribute on form elements *)
   match name with
   | "input" | "select" | "textarea" ->
-      (match get_attr "autocomplete" attrs with
+      (match Attr_utils.get_attr "autocomplete" attrs with
       | Some autocomplete_value ->
           check_autocomplete_value autocomplete_value name collector
       | None -> ())

lib/htmlrw_check/semantic/lang_detecting_checker.ml

···
   let n = String.lowercase_ascii name in
   n = "svg" || n = "math"
 
-let get_attr name attrs =
-  List.find_map (fun (n, v) ->
-    if String.lowercase_ascii n = name then Some v else None
-  ) attrs
-
 let get_lang_code lang =
   (* Extract primary language subtag *)
   match String.split_on_char '-' lang with
···
   let ns = Option.value namespace ~default:"" in
 
   if name_lower = "html" then begin
-    state.html_lang <- get_attr "lang" attrs;
-    state.html_dir <- get_attr "dir" attrs;
+    state.html_lang <- Attr_utils.get_attr "lang" attrs;
+    state.html_dir <- Attr_utils.get_attr "dir" attrs;
     (* TODO: get line/column from locator *)
     state.html_locator <- Some (1, 1)
   end
···
       state.skip_depth <- state.skip_depth + 1
     else begin
       (* Check for different lang attribute *)
-      match get_attr "lang" attrs with
+      match Attr_utils.get_attr "lang" attrs with
       | Some lang when state.html_lang <> Some lang ->
           state.skip_depth <- state.skip_depth + 1
       | _ -> ()

lib/htmlrw_check/semantic/option_checker.ml

···
   state.option_stack <- [];
   state.in_template <- 0
 
-(** Get attribute value if present. *)
-let get_attr name attrs =
-  List.find_map (fun (attr_name, value) ->
-    if String.lowercase_ascii attr_name = name then Some value else None
-  ) attrs
-
 let start_element state ~name ~namespace ~attrs collector =
   let name_lower = String.lowercase_ascii name in
 
···
     if name_lower = "template" then
       state.in_template <- state.in_template + 1
     else if state.in_template = 0 && name_lower = "option" then begin
-      let label_opt = get_attr "label" attrs in
+      let label_opt = Attr_utils.get_attr "label" attrs in
       let has_label = label_opt <> None in
       let label_empty = match label_opt with
         | Some v -> String.trim v = ""

lib/htmlrw_check/semantic/required_attr_checker.ml

···
   state._in_figure <- false;
   state.in_a_with_href <- 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 state attrs collector =
   (* Check for required src OR srcset attribute *)
-  if not (has_attr "src" attrs) && not (has_attr "srcset" attrs) then
+  if not (Attr_utils.has_attr "src" attrs) && not (Attr_utils.has_attr "srcset" attrs) then
     Message_collector.add_typed collector (`Img `Missing_src_or_srcset);
 
   (* Check for alt attribute - always required *)
-  if not (has_attr "alt" attrs) then
+  if not (Attr_utils.has_attr "alt" attrs) then
     Message_collector.add_typed collector (`Img `Missing_alt);
 
   (* Check ismap requires 'a' ancestor with href *)
-  if has_attr "ismap" attrs && not state.in_a_with_href then
+  if Attr_utils.has_attr "ismap" attrs && not state.in_a_with_href then
     Message_collector.add_typed collector (`Img `Ismap_needs_href)
 
 let check_area_element attrs collector =
   (* area with href requires alt *)
-  if has_attr "href" attrs && not (has_attr "alt" attrs) then
+  if Attr_utils.has_attr "href" attrs && not (Attr_utils.has_attr "alt" attrs) then
     Message_collector.add_typed collector
       (`Attr (`Missing (`Elem "area", `Attr "alt")))
 
 let check_input_element attrs collector =
-  match get_attr "type" attrs with
+  match Attr_utils.get_attr "type" attrs with
   | Some "image" ->
       (* input[type=image] requires alt *)
-      if not (has_attr "alt" attrs) then
+      if not (Attr_utils.has_attr "alt" attrs) then
         Message_collector.add_typed collector
           (`Attr (`Missing (`Elem "input", `Attr "alt")))
   | Some "hidden" ->
       (* input[type=hidden] should not have required attribute *)
-      if has_attr "required" attrs then
+      if Attr_utils.has_attr "required" attrs then
         Message_collector.add_typed collector
           (`Attr (`Not_allowed_when (`Attr "required", `Elem "input", `Condition "the type attribute is hidden")))
   | Some "file" ->
       (* input[type=file] should not have value attribute *)
-      if has_attr "value" attrs then
+      if Attr_utils.has_attr "value" attrs then
         Message_collector.add_typed collector
           (`Attr (`Not_allowed_when (`Attr "value", `Elem "input", `Condition "the type attribute is file")))
   | _ -> ()
 
 let check_script_element attrs _collector =
   (* script requires src OR text content *)
-  if not (has_attr "src" attrs) then
+  if not (Attr_utils.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 *)
     ()
···
      - http-equiv AND content
      - property AND content (RDFa)
      - itemprop AND content (microdata) *)
-  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 has_property = has_attr "property" attrs in
-  let has_itemprop = has_attr "itemprop" attrs in
+  let has_charset = Attr_utils.has_attr "charset" attrs in
+  let has_name = Attr_utils.has_attr "name" attrs in
+  let has_content = Attr_utils.has_attr "content" attrs in
+  let has_http_equiv = Attr_utils.has_attr "http-equiv" attrs in
+  let has_property = Attr_utils.has_attr "property" attrs in
+  let has_itemprop = Attr_utils.has_attr "itemprop" attrs in
 
   let valid =
     has_charset
···
 
 let check_link_element attrs collector =
   (* link[rel="stylesheet"] requires href *)
-  match get_attr "rel" attrs with
+  match Attr_utils.get_attr "rel" attrs with
   | Some rel when String.equal rel "stylesheet" ->
-      if not (has_attr "href" attrs) then
+      if not (Attr_utils.has_attr "href" attrs) then
         Message_collector.add_typed collector (`Link `Missing_href)
   | _ -> ()
 
 let check_a_element attrs collector =
   (* a[download] requires href *)
-  if has_attr "download" attrs && not (has_attr "href" attrs) then
+  if Attr_utils.has_attr "download" attrs && not (Attr_utils.has_attr "href" attrs) then
     Message_collector.add_typed collector
       (`Attr (`Missing (`Elem "a", `Attr "href")))
 
 let check_map_element attrs collector =
   (* map requires name *)
-  if not (has_attr "name" attrs) then
+  if not (Attr_utils.has_attr "name" attrs) then
     Message_collector.add_typed collector
       (`Attr (`Missing (`Elem "map", `Attr "name")))
 
 let check_object_element attrs collector =
   (* object requires data attribute (or type attribute alone is not sufficient) *)
-  let has_data = has_attr "data" attrs in
-  let has_type = has_attr "type" attrs in
+  let has_data = Attr_utils.has_attr "data" attrs in
+  let has_type = Attr_utils.has_attr "type" attrs in
   if not has_data && has_type then
     Message_collector.add_typed collector
       (`Attr (`Missing (`Elem "object", `Attr "data")))
 
 let check_popover_element element_name attrs collector =
   (* popover attribute must have valid value *)
-  match get_attr "popover" attrs with
+  match Attr_utils.get_attr "popover" attrs with
   | Some value ->
     let value_lower = String.lowercase_ascii value in
     (* Valid values: empty string, auto, manual, hint *)
···
 
 let check_meter_element attrs collector =
   (* meter requires value attribute *)
-  if not (has_attr "value" attrs) then
+  if not (Attr_utils.has_attr "value" attrs) then
     Message_collector.add_typed collector
       (`Attr (`Missing (`Elem "meter", `Attr "value")))
   else begin
     (* Validate min <= value constraint *)
-    match get_attr "value" attrs, get_attr "min" attrs with
+    match Attr_utils.get_attr "value" attrs, Attr_utils.get_attr "min" attrs with
     | Some value_str, Some min_str ->
         (try
           let value = float_of_string value_str in
···
 
 let check_progress_element attrs collector =
   (* Validate progress value constraints *)
-  match get_attr "value" attrs with
+  match Attr_utils.get_attr "value" attrs with
   | None -> ()  (* value is optional *)
   | Some value_str ->
       (try
         let value = float_of_string value_str in
-        let max_val = match get_attr "max" attrs with
+        let max_val = match Attr_utils.get_attr "max" attrs with
           | None -> 1.0  (* default max is 1 *)
           | Some max_str -> (try float_of_string max_str with _ -> 1.0)
         in
         if value > max_val then
           let q s = "\xe2\x80\x9c" ^ s ^ "\xe2\x80\x9d" in
           (* Check which message to use based on whether max is present *)
-          if has_attr "max" attrs then
+          if Attr_utils.has_attr "max" attrs then
             Message_collector.add_typed collector
               (`Generic (
                 (* Note: double space before "value" matches Nu validator quirk *)
···
   | "link" -> check_link_element attrs collector
   | "a" ->
       check_a_element attrs collector;
-      if has_attr "href" attrs then state.in_a_with_href <- true
+      if Attr_utils.has_attr "href" attrs then state.in_a_with_href <- true
   | "map" -> check_map_element attrs collector
   | "object" -> check_object_element attrs collector
   | "meter" -> check_meter_element attrs collector
···
   | "figure" -> state._in_figure <- true
   | _ ->
     (* Check popover attribute on any element *)
-    if has_attr "popover" attrs then check_popover_element name attrs collector
+    if Attr_utils.has_attr "popover" attrs then check_popover_element name attrs collector
 
 let end_element state ~name ~namespace:_ _collector =
   match name with

lib/htmlrw_check/specialized/aria_checker.ml

···
       if name_lower = "br" || name_lower = "wbr" then begin
         List.iter (fun (attr_name, _) ->
           let attr_lower = String.lowercase_ascii attr_name in
-          if String.length attr_lower > 5 && String.sub attr_lower 0 5 = "aria-" &&
+          if String.starts_with ~prefix:"aria-" attr_lower &&
              attr_lower <> "aria-hidden" then
             Message_collector.add_typed collector
               (`Attr (`Not_allowed (`Attr attr_name, `Elem name)))

lib/htmlrw_check/specialized/attr_restrictions_checker.ml

···
 let create () = { is_xhtml = false }
 let reset state = state.is_xhtml <- false
 
-(** Check if an attribute list contains a specific attribute. *)
-let has_attr name attrs =
-  List.exists (fun (attr_name, _) -> String.lowercase_ascii attr_name = name) attrs
-
-(** Get an attribute value from the list. *)
-let get_attr name attrs =
-  List.find_map (fun (attr_name, value) ->
-    if String.lowercase_ascii attr_name = name then Some value else None
-  ) attrs
-
 (** Input types that allow the list attribute. *)
 let input_types_allowing_list = [
   "color"; "date"; "datetime-local"; "email"; "month"; "number";
···
 
   (* Detect XHTML mode from xmlns attribute on html element *)
   if name_lower = "html" then begin
-    let xmlns_value = get_attr "xmlns" attrs in
-    match xmlns_value with
+    match Attr_utils.get_attr "xmlns" attrs with
     | Some "http://www.w3.org/1999/xhtml" -> state.is_xhtml <- true
     | _ -> ()
   end;
 
   (* Check HTML element attribute restrictions *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     match List.assoc_opt name_lower disallowed_attrs_html with
     | Some disallowed ->
       List.iter (fun attr ->
-        if has_attr attr attrs then
+        if Attr_utils.has_attr attr attrs then
           report_disallowed_attr name_lower attr collector
       ) disallowed
-    | None -> ()
-  end;
+    | None -> ());
 
   (* Check for xml:base attribute - not allowed in HTML *)
-  if namespace = None && name_lower = "html" then begin
-    if has_attr "xml:base" attrs then
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "html" ->
+    if Attr_utils.has_attr "xml:base" attrs then
       report_disallowed_attr name_lower "xml:base" collector
-  end;
+  | None -> ());
 
   (* Check for xmlns:* prefixed attributes - not allowed in HTML *)
   (* Standard xmlns declarations are allowed but custom prefixes are not *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     List.iter (fun (attr_name, _) ->
       let attr_lower = String.lowercase_ascii attr_name in
-      if String.length attr_lower > 6 && String.sub attr_lower 0 6 = "xmlns:" then begin
+      if String.starts_with ~prefix:"xmlns:" attr_lower then begin
         let prefix = String.sub attr_lower 6 (String.length attr_lower - 6) in
         (* Only xmlns:xlink (with correct value) and xmlns:xml are allowed *)
         if prefix <> "xlink" && prefix <> "xml" then
           Message_collector.add_typed collector
             (`Attr (`Not_allowed_here (`Attr attr_name)))
       end
-    ) attrs
-  end;
+    ) attrs);
 
   (* Check SVG element restrictions - works in both HTML-embedded and XHTML SVG *)
   (* xml:id is never valid on SVG elements in HTML5 *)
   if List.mem name_lower svg_no_xml_id then begin
-    if has_attr "xml:id" attrs then
+    if Attr_utils.has_attr "xml:id" attrs then
       report_disallowed_attr name_lower "xml:id" collector
   end;
 
   (* SVG feConvolveMatrix requires order attribute *)
   if name_lower = "feconvolvematrix" then begin
-    if not (has_attr "order" attrs) then
+    if not (Attr_utils.has_attr "order" attrs) then
       Message_collector.add_typed collector
         (`Svg (`Missing_attr (`Elem "feConvolveMatrix", `Attr "order")))
   end;
 
   (* Validate style type attribute - must be "text/css" or omitted *)
-  if namespace = None && name_lower = "style" then begin
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "style" ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "type" then begin
···
           Message_collector.add_typed collector (`Misc `Style_type_invalid)
       end
     ) attrs
-  end;
+  | None -> ());
 
   (* Validate object element requires data or type attribute *)
-  if namespace = None && name_lower = "object" then begin
-    let has_data = has_attr "data" attrs in
-    let has_type = has_attr "type" attrs in
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "object" ->
+    let has_data = Attr_utils.has_attr "data" attrs in
+    let has_type = Attr_utils.has_attr "type" attrs in
     if not has_data && not has_type then
       Message_collector.add_typed collector
         (`Attr (`Missing (`Elem "object", `Attr "data")))
-  end;
+  | None -> ());
 
   (* Validate link imagesizes/imagesrcset attributes *)
-  if namespace = None && name_lower = "link" then begin
-    let has_imagesizes = has_attr "imagesizes" attrs in
-    let has_imagesrcset = has_attr "imagesrcset" attrs in
-    let rel_value = get_attr "rel" attrs in
-    let as_value = get_attr "as" attrs in
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "link" ->
+    let has_imagesizes = Attr_utils.has_attr "imagesizes" attrs in
+    let has_imagesrcset = Attr_utils.has_attr "imagesrcset" attrs in
+    let rel_value = Attr_utils.get_attr "rel" attrs in
+    let as_value = Attr_utils.get_attr "as" attrs in
 
     (* imagesizes requires imagesrcset *)
     if has_imagesizes && not has_imagesrcset then
···
       if not rel_is_preload then
         Message_collector.add_typed collector (`Link `As_requires_preload)
     | None -> ())
-  end;
+  | None -> ());
 
   (* Validate img usemap attribute - must be hash-name reference with content *)
-  if namespace = None && name_lower = "img" then begin
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "img" ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "usemap" then begin
···
               attr_value attr_name name))))
       end
     ) attrs
-  end;
+  | None -> ());
 
   (* Validate embed type attribute - must be valid MIME type *)
-  if namespace = None && name_lower = "embed" then begin
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "embed" ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "type" then begin
···
               attr_value attr_name name msg))))
       end
     ) attrs
-  end;
+  | None -> ());
 
   (* Validate width/height on embed and img - must be non-negative integers *)
-  if namespace = None && (name_lower = "embed" || name_lower = "img" ||
-                          name_lower = "video" || name_lower = "canvas" ||
-                          name_lower = "iframe" || name_lower = "source") then begin
+  let is_dimension_element = name_lower = "embed" || name_lower = "img" ||
+                             name_lower = "video" || name_lower = "canvas" ||
+                             name_lower = "iframe" || name_lower = "source" in
+  (match namespace with
+  | Some _ -> ()
+  | None when is_dimension_element ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "width" || attr_lower = "height" then begin
···
         end
       end
     ) attrs
-  end;
+  | None -> ());
 
   (* Validate area[shape=default] cannot have coords *)
-  if namespace = None && name_lower = "area" then begin
-    let shape_value = get_attr "shape" attrs in
-    match shape_value with
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "area" ->
+    (match Attr_utils.get_attr "shape" attrs with
     | Some s when String.lowercase_ascii (String.trim s) = "default" ->
-      if has_attr "coords" attrs then
+      if Attr_utils.has_attr "coords" attrs then
         Message_collector.add_typed collector
           (`Attr (`Not_allowed (`Attr "coords", `Elem "area")))
-    | _ -> ()
-  end;
+    | _ -> ())
+  | None -> ());
 
   (* Validate bdo element requires dir attribute, and dir cannot be "auto" *)
-  if namespace = None && name_lower = "bdo" then begin
-    let dir_value = get_attr "dir" attrs in
-    match dir_value with
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "bdo" ->
+    (match Attr_utils.get_attr "dir" attrs with
     | None ->
       Message_collector.add_typed collector (`Misc `Bdo_missing_dir)
     | Some v when String.lowercase_ascii (String.trim v) = "auto" ->
       Message_collector.add_typed collector (`Misc `Bdo_dir_auto)
-    | _ -> ()
-  end;
+    | _ -> ())
+  | None -> ());
 
   (* Validate input list attribute - only allowed for certain types *)
-  if namespace = None && name_lower = "input" then begin
-    if has_attr "list" attrs then begin
-      let input_type = match get_attr "type" attrs with
-        | Some t -> String.lowercase_ascii (String.trim t)
-        | None -> "text"  (* default type is text *)
-      in
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "input" ->
+    if Attr_utils.has_attr "list" attrs then begin
+      let input_type = Attr_utils.get_attr_or "type" ~default:"text" attrs
+                       |> String.trim |> String.lowercase_ascii in
       if not (List.mem input_type input_types_allowing_list) then
         Message_collector.add_typed collector (`Input `List_not_allowed)
     end
-  end;
+  | None -> ());
 
   (* Validate data-* attributes *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     List.iter (fun (attr_name, _) ->
       let attr_lower = String.lowercase_ascii attr_name in
       (* Check if it starts with "data-" *)
-      if String.length attr_lower >= 5 && String.sub attr_lower 0 5 = "data-" then begin
+      if String.starts_with ~prefix:"data-" attr_lower then begin
         let after_prefix = String.sub attr_lower 5 (String.length attr_lower - 5) in
         (* Check if it's exactly "data-" with nothing after *)
         if after_prefix = "" then
···
           Message_collector.add_typed collector
             (`Attr (`Data_invalid_name (`Reason "must be XML 1.0 4th ed. plus Namespaces NCNames")))
       end
-    ) attrs
-  end;
+    ) attrs);
 
   (* Validate xml:lang must have matching lang attribute - only in HTML mode, not XHTML *)
-  if namespace = None && not state.is_xhtml then begin
-    let xmllang_value = get_attr "xml:lang" attrs in
-    let lang_value = get_attr "lang" attrs in
-    match xmllang_value with
+  (match namespace with
+  | Some _ -> ()
+  | None when not state.is_xhtml ->
+    let xmllang_value = Attr_utils.get_attr "xml:lang" attrs in
+    let lang_value = Attr_utils.get_attr "lang" attrs in
+    (match xmllang_value with
     | Some xmllang ->
       (match lang_value with
        | None ->
-         (* xml:lang without lang attribute *)
          Message_collector.add_typed collector (`I18n `Xml_lang_without_lang)
        | Some lang when String.lowercase_ascii lang <> String.lowercase_ascii xmllang ->
-         (* xml:lang and lang have different values - "lang present with same value" message *)
          Message_collector.add_typed collector (`I18n `Xml_lang_without_lang)
        | _ -> ())
-    | None -> ()
-  end;
+    | None -> ())
+  | None -> ());
 
   (* Validate spellcheck attribute - must be "true" or "false" or empty *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "spellcheck" then begin
···
           Message_collector.add_typed collector
             (`Attr (`Bad_value (`Elem name, `Attr attr_name, `Value attr_value, `Reason "")))
       end
-    ) attrs
-  end;
+    ) attrs);
 
   (* Validate enterkeyhint attribute - must be one of specific values *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     let valid_enterkeyhint = ["enter"; "done"; "go"; "next"; "previous"; "search"; "send"] in
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
···
           Message_collector.add_typed collector
             (`Attr (`Bad_value (`Elem name, `Attr attr_name, `Value attr_value, `Reason "")))
       end
-    ) attrs
-  end;
+    ) attrs);
 
   (* Validate headingoffset attribute - must be a number between 0 and 8 *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "headingoffset" then begin
···
         if not is_valid then
           Message_collector.add_typed collector (`Misc `Headingoffset_invalid)
       end
-    ) attrs
-  end;
+    ) attrs);
 
   (* Validate accesskey attribute - each key label must be a single code point *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "accesskey" then begin
···
         in
         find_duplicates [] keys
       end
-    ) attrs
-  end;
+    ) attrs);
 
   (* Validate that command and popovertarget cannot have aria-expanded *)
-  if namespace = None && name_lower = "button" then begin
-    let has_command = has_attr "command" attrs in
-    let has_popovertarget = has_attr "popovertarget" attrs in
-    let has_aria_expanded = has_attr "aria-expanded" attrs in
+  (match namespace with
+  | Some _ -> ()
+  | None when name_lower = "button" ->
+    let has_command = Attr_utils.has_attr "command" attrs in
+    let has_popovertarget = Attr_utils.has_attr "popovertarget" attrs in
+    let has_aria_expanded = Attr_utils.has_attr "aria-expanded" attrs in
 
     if has_command && has_aria_expanded then
       Message_collector.add_typed collector
···
       Message_collector.add_typed collector
         (`Attr (`Not_allowed_when (`Attr "aria-expanded", `Elem name,
           `Condition "a \xe2\x80\x9cpopovertarget\xe2\x80\x9d attribute")))
-  end;
+  | None -> ());
 
   (* Note: data-* uppercase check requires XML parsing which preserves case.
      The HTML5 parser normalizes attribute names to lowercase, so this check
···
   ignore state.is_xhtml;
 
   (* Validate media attribute on link, style, source elements *)
-  if namespace = None && (name_lower = "link" || name_lower = "style" || name_lower = "source") then begin
+  let is_media_element = name_lower = "link" || name_lower = "style" || name_lower = "source" in
+  (match namespace with
+  | Some _ -> ()
+  | None when is_media_element ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "media" then begin
···
         end
       end
     ) attrs
-  end;
+  | None -> ());
 
   (* Validate RDFa prefix attribute - space-separated list of prefix:iri pairs *)
-  if namespace = None then begin
+  (match namespace with
+  | Some _ -> ()
+  | None ->
     List.iter (fun (attr_name, attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
       if attr_lower = "prefix" then begin
···
           end
         end
       end
-    ) attrs
-  end
+    ) attrs)
 
 let end_element _state ~name:_ ~namespace:_ _collector = ()
 let characters _state _text _collector = ()

lib/htmlrw_check/specialized/base_checker.ml

···
 let reset state =
   state.seen_link_or_script <- false
 
-(** Check if an attribute list contains a specific attribute. *)
-let has_attr name attrs =
-  List.exists (fun (attr_name, _) -> String.lowercase_ascii attr_name = name) attrs
-
 let start_element state ~name ~namespace ~attrs collector =
-  if namespace <> None then ()
-  else begin
-    let name_lower = String.lowercase_ascii name in
-    match name_lower with
+  match namespace with
+  | Some _ -> ()
+  | None ->
+    match String.lowercase_ascii name with
     | "link" | "script" ->
       state.seen_link_or_script <- true
     | "base" ->
       if state.seen_link_or_script then
         Message_collector.add_typed collector (`Misc `Base_after_link_script);
       (* base element must have href or target attribute *)
-      let has_href = has_attr "href" attrs in
-      let has_target = has_attr "target" attrs in
-      if not has_href && not has_target then
+      if not (Attr_utils.has_attr "href" attrs || Attr_utils.has_attr "target" attrs) then
         Message_collector.add_typed collector (`Misc `Base_missing_href_or_target)
     | _ -> ()
-  end
 
 let end_element _state ~name:_ ~namespace:_ _collector = ()
 let characters _state _text _collector = ()

lib/htmlrw_check/specialized/dl_checker.ml

···
   | ctx :: _ -> Some ctx
   | [] -> None
 
-let get_attr name attrs =
-  List.find_map (fun (n, v) ->
-    if String.lowercase_ascii n = name then Some v else None
-  ) attrs
-
 let start_element state ~name ~namespace ~attrs collector =
   let name_lower = String.lowercase_ascii name in
 
···
           Message_collector.add_typed collector
             (`Element (`Not_allowed_as_child (`Child "div", `Parent "dl")));
         (* Check that role is only presentation or none *)
-        (match get_attr "role" attrs with
+        (match Attr_utils.get_attr "role" attrs with
         | Some role_value ->
           let role_lower = String.lowercase_ascii (String.trim role_value) in
           if role_lower <> "presentation" && role_lower <> "none" then

lib/htmlrw_check/specialized/picture_checker.ml

···
   state.always_matching_is_media_all <- false;
   state.always_matching_is_media_empty <- false
 
-(** Check if an attribute list contains a specific attribute. *)
-let has_attr name attrs =
-  List.exists (fun (attr_name, _) -> String.lowercase_ascii attr_name = name) attrs
-
 (** Report disallowed attribute error *)
 let report_disallowed_attr element attr collector =
   Message_collector.add_typed collector
···
   Message_collector.add_typed collector
     (`Element (`Not_allowed_as_child (`Child child, `Parent parent)))
 
+let check_disallowed_attrs element disallowed_list attrs collector =
+  List.iter (fun attr ->
+    if Attr_utils.has_attr attr attrs then
+      report_disallowed_attr element attr collector
+  ) disallowed_list
+
 let check_picture_attrs attrs collector =
-  List.iter (fun disallowed ->
-    if has_attr disallowed attrs then
-      report_disallowed_attr "picture" disallowed collector
-  ) disallowed_picture_attrs
+  check_disallowed_attrs "picture" disallowed_picture_attrs attrs collector
 
 let check_source_attrs_in_picture attrs collector =
-  List.iter (fun disallowed ->
-    if has_attr disallowed attrs then
-      report_disallowed_attr "source" disallowed collector
-  ) disallowed_source_attrs_in_picture;
-  (* source in picture requires srcset *)
-  if not (has_attr "srcset" attrs) then
-    Message_collector.add_typed collector
-      (`Srcset `Source_missing_srcset)
+  check_disallowed_attrs "source" disallowed_source_attrs_in_picture attrs collector;
+  if not (Attr_utils.has_attr "srcset" attrs) then
+    Message_collector.add_typed collector (`Srcset `Source_missing_srcset)
 
 let check_img_attrs attrs collector =
-  List.iter (fun disallowed ->
-    if has_attr disallowed attrs then
-      report_disallowed_attr "img" disallowed collector
-  ) disallowed_img_attrs
+  check_disallowed_attrs "img" disallowed_img_attrs attrs collector
 
 let start_element state ~name ~namespace ~attrs collector =
   let name_lower = String.lowercase_ascii name in
···
   end;
 
   (* Rest of checks only apply to HTML namespace elements *)
-  if namespace = None then begin
-    match name_lower with
+  match namespace with
+  | Some _ -> ()
+  | None ->
+    (match name_lower with
     | "picture" ->
       (* Check if picture is in a disallowed parent context *)
       (match state.parent_stack with
···
       check_picture_attrs attrs collector;
       state.in_picture <- true;
       state.has_img_in_picture <- false;
-      state.picture_depth <- 0;  (* Will be incremented to 1 at end of function *)
+      state.picture_depth <- 0;
       state.children_in_picture <- [];
       state.last_was_img <- false;
       state.has_source_after_img <- false;
···
       state.children_in_picture <- "source" :: state.children_in_picture;
       if state.last_was_img then
         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
+      (* A source is "always matching" if it has no media/type, or media="" or media="all" *)
+      let media_value = Attr_utils.get_attr "media" attrs in
+      let has_type = Attr_utils.has_attr "type" attrs in
       let is_media_all = match media_value with
         | Some v -> String.lowercase_ascii (String.trim v) = "all"
-        | None -> false
-      in
+        | None -> false in
       let is_media_empty = match media_value with
         | Some v -> String.trim v = ""
-        | None -> false
-      in
+        | None -> false in
       let is_always_matching = match media_value with
-        | None -> not has_type  (* no media, check if no type either *)
+        | None -> not has_type
         | Some v ->
           let trimmed = String.trim v in
           trimmed = "" || String.lowercase_ascii trimmed = "all"
       in
       if is_always_matching then begin
         state.has_always_matching_source <- true;
-        if is_media_all then
-          state.always_matching_is_media_all <- true
-        else if is_media_empty then
-          state.always_matching_is_media_empty <- true
+        (* Only set flags to true, never reset to false *)
+        if is_media_all then state.always_matching_is_media_all <- true;
+        if is_media_empty then state.always_matching_is_media_empty <- true
       end
 
     | "img" when state.in_picture && state.picture_depth = 1 ->
···
       state.has_img_in_picture <- true;
       state.children_in_picture <- "img" :: state.children_in_picture;
       state.last_was_img <- true;
-      (* Check for multiple img elements *)
-      let img_count = List.filter (fun c -> c = "img") state.children_in_picture |> List.length in
+      let img_count = List.length (List.filter (( = ) "img") state.children_in_picture) in
       if img_count > 1 then
         report_disallowed_child "picture" "img" collector;
-      (* Check if always-matching source is followed by img with srcset *)
-      if state.has_always_matching_source && has_attr "srcset" attrs then begin
-        if state.always_matching_is_media_all then
-          Message_collector.add_typed collector (`Misc `Media_all)
-        else if state.always_matching_is_media_empty then
-          Message_collector.add_typed collector (`Misc `Media_empty)
-        else
-          Message_collector.add_typed collector (`Srcset `Source_needs_media_or_type)
-      end
+      if state.has_always_matching_source && Attr_utils.has_attr "srcset" attrs then
+        Message_collector.add_typed collector
+          (if state.always_matching_is_media_all then `Misc `Media_all
+           else if state.always_matching_is_media_empty then `Misc `Media_empty
+           else `Srcset `Source_needs_media_or_type)
 
     | "script" when state.in_picture && state.picture_depth = 1 ->
       state.children_in_picture <- "script" :: state.children_in_picture
···
     | "img" ->
       check_img_attrs attrs collector
 
-    | _ -> ()
-  end;
+    | _ -> ());
 
   (* Track depth when inside picture *)
   if state.in_picture then
···
     state.parent_stack <- name_lower :: state.parent_stack
 
 let end_element state ~name ~namespace collector =
-  if namespace <> None then ()
-  else begin
+  match namespace with
+  | Some _ -> ()
+  | None ->
     let name_lower = String.lowercase_ascii name in
 
-    (* Track depth *)
     if state.in_picture then
       state.picture_depth <- state.picture_depth - 1;
 
     if name_lower = "picture" && state.picture_depth = 0 then begin
-      (* Check if picture had img child *)
       if not state.has_img_in_picture then
-        Message_collector.add_typed collector
-          (`Srcset `Picture_missing_img);
-      (* Check for source after img *)
+        Message_collector.add_typed collector (`Srcset `Picture_missing_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 begin
-        if state.always_matching_is_media_all then
-          Message_collector.add_typed collector (`Misc `Media_all)
-        else if state.always_matching_is_media_empty then
-          Message_collector.add_typed collector (`Misc `Media_empty)
-        else
-          Message_collector.add_typed collector (`Srcset `Source_needs_media_or_type)
-      end;
-
+      if state.source_after_always_matching then
+        Message_collector.add_typed collector
+          (if state.always_matching_is_media_all then `Misc `Media_all
+           else if state.always_matching_is_media_empty then `Misc `Media_empty
+           else `Srcset `Source_needs_media_or_type);
       state.in_picture <- false
     end;
 
-    (* Pop from parent stack *)
-    state.parent_stack <- (match state.parent_stack with
-      | _ :: rest -> rest
-      | [] -> [])
-  end
+    state.parent_stack <- match state.parent_stack with _ :: rest -> rest | [] -> []
 
 let characters state text collector =
   (* Text in picture element is not allowed *)

lib/htmlrw_check/specialized/source_checker.ml

···
   | ctx :: _ -> ctx
   | [] -> Other
 
-(** Check if an attribute list contains a specific attribute. *)
-let has_attr name attrs =
-  List.exists (fun (attr_name, _) -> String.lowercase_ascii attr_name = name) attrs
-
 let start_element state ~name ~namespace ~attrs collector =
   if namespace <> None then ()
   else begin
···
       let ctx = current_context state in
       begin match ctx with
       | Video | Audio ->
-        if has_attr "srcset" attrs then
+        if Attr_utils.has_attr "srcset" attrs then
           Message_collector.add_typed collector
             (`Attr (`Not_allowed (`Attr "srcset", `Elem "source")));
-        if has_attr "sizes" attrs then
+        if Attr_utils.has_attr "sizes" attrs then
           Message_collector.add_typed collector
             (`Attr (`Not_allowed (`Attr "sizes", `Elem "source")));
-        if has_attr "width" attrs then
+        if Attr_utils.has_attr "width" attrs then
           Message_collector.add_typed collector
             (`Attr (`Not_allowed (`Attr "width", `Elem "source")));
-        if has_attr "height" attrs then
+        if Attr_utils.has_attr "height" attrs then
           Message_collector.add_typed collector
             (`Attr (`Not_allowed (`Attr "height", `Elem "source")))
       | Picture | Other -> ()

lib/htmlrw_check/specialized/srcset_sizes_checker.ml

···
 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
-
 (** Split string on a character while respecting parentheses *)
 let split_respecting_parens ~sep s =
   let len = String.length s in
···
 
   (* SVG image elements should not have srcset *)
   if namespace <> None && name_lower = "image" then begin
-    if get_attr "srcset" attrs <> None then
+    if Attr_utils.get_attr "srcset" attrs <> None then
       Message_collector.add_typed collector
         (`Attr (`Not_allowed (`Attr "srcset", `Elem "image")))
   end;
···
   else begin
     (* 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 sizes_value = Attr_utils.get_attr "sizes" attrs in
+      let srcset_value = Attr_utils.get_attr "srcset" attrs in
       let has_sizes = sizes_value <> None in
       let has_srcset = srcset_value <> None in
 

lib/htmlrw_check/specialized/xhtml_content_checker.ml

···
 (* Check if data-* attribute has uppercase characters *)
 let check_data_attr_case attrs collector =
   List.iter (fun (attr_name, _) ->
-    if String.length attr_name > 5 &&
-       String.sub attr_name 0 5 = "data-" then
+    if String.starts_with ~prefix:"data-" attr_name then
       let suffix = String.sub attr_name 5 (String.length attr_name - 5) in
       if String.exists (fun c -> c >= 'A' && c <= 'Z') suffix then
         Message_collector.add_typed collector (`Attr `Data_uppercase)