refactors

lib/check/ancestor_tracker.ml

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+(** Generic ancestor tracking for DOM traversal. *)
+
+type 'data context = {
+  name : string;
+  data : 'data;
+}
+
+type 'data t = {
+  mutable stack : 'data context list;
+}
+
+let create () = { stack = [] }
+
+let reset tracker = tracker.stack <- []
+
+let push tracker name data =
+  let name_lower = Astring.String.Ascii.lowercase name in
+  let context = { name = name_lower; data } in
+  tracker.stack <- context :: tracker.stack
+
+let pop tracker =
+  match tracker.stack with
+  | [] -> () (* Gracefully handle underflow *)
+  | _ :: rest -> tracker.stack <- rest
+
+let peek tracker =
+  match tracker.stack with
+  | [] -> None
+  | hd :: _ -> Some hd
+
+let depth tracker = List.length tracker.stack
+
+let has_ancestor tracker name =
+  let name_lower = Astring.String.Ascii.lowercase name in
+  List.exists (fun ctx -> String.equal ctx.name name_lower) tracker.stack
+
+let has_ancestor_with tracker predicate =
+  List.exists (fun ctx -> predicate ctx.name ctx.data) tracker.stack
+
+let find_ancestor tracker name =
+  let name_lower = Astring.String.Ascii.lowercase name in
+  List.find_opt (fun ctx -> String.equal ctx.name name_lower) tracker.stack
+
+let find_ancestor_with tracker predicate =
+  List.find_opt (fun ctx -> predicate ctx.name ctx.data) tracker.stack
+
+let get_all_ancestors tracker = tracker.stack
+
+let filter_ancestors tracker predicate =
+  List.filter (fun ctx -> predicate ctx.name ctx.data) tracker.stack
+
+let exists = has_ancestor_with
+
+let for_all tracker predicate =
+  List.for_all (fun ctx -> predicate ctx.name ctx.data) tracker.stack
+
+let iter tracker f =
+  List.iter (fun ctx -> f ctx.name ctx.data) tracker.stack
+
+let fold tracker f init =
+  List.fold_left (fun acc ctx -> f acc ctx.name ctx.data) init tracker.stack
+
+let get_parent = peek
+
+let get_parent_name tracker =
+  match peek tracker with
+  | Some ctx -> Some ctx.name
+  | None -> None
+
+let get_parent_data tracker =
+  match peek tracker with
+  | Some ctx -> Some ctx.data
+  | None -> None
+
+let has_any_ancestor tracker names =
+  let names_lower = List.map Astring.String.Ascii.lowercase names in
+  List.exists (fun ctx -> List.mem ctx.name names_lower) tracker.stack
+
+let find_first_matching tracker names =
+  let names_lower = List.map Astring.String.Ascii.lowercase names in
+  List.find_map (fun ctx ->
+    if List.mem ctx.name names_lower then Some (ctx.name, ctx)
+    else None
+  ) tracker.stack
+
+let is_empty tracker = tracker.stack = []
+
+let to_list = get_all_ancestors
+
+let to_name_list tracker =
+  List.map (fun ctx -> ctx.name) tracker.stack

lib/check/ancestor_tracker.mli

···
+(*---------------------------------------------------------------------------
+  Copyright (c) 2025 Anil Madhavapeddy <[e-mail]>. All rights reserved.
+  SPDX-License-Identifier: MIT
+ ---------------------------------------------------------------------------*)
+
+(** Generic ancestor tracking for DOM traversal.
+
+    This module provides a generic stack-based ancestor tracker that can be
+    used by various HTML checkers to track element nesting during DOM
+    traversal. It is parameterized by the type of data stored per element.
+
+    {2 Design}
+
+    The tracker maintains a stack of element contexts, where each context
+    contains:
+    - The element name (string)
+    - Custom data of type ['data] (checker-specific)
+
+    The stack is automatically managed through [push] and [pop] operations
+    that should be called in response to start_element and end_element events.
+
+    {2 Usage Example}
+
+    {[
+      (* Define custom data type *)
+      type role_data = {
+        explicit_roles : string list;
+        implicit_role : string option;
+      }
+
+      (* Create tracker *)
+      let tracker = Ancestor_tracker.create ()
+
+      (* Push element context *)
+      let data = { explicit_roles = ["button"]; implicit_role = None } in
+      Ancestor_tracker.push tracker "div" data;
+
+      (* Query ancestors *)
+      let has_button = Ancestor_tracker.exists tracker
+        (fun name data -> List.mem "button" data.explicit_roles)
+      in
+
+      (* Pop when element closes *)
+      Ancestor_tracker.pop tracker
+    ]}
+*)
+
+(** {1 Types} *)
+
+(** Ancestor context containing element name and custom data. *)
+type 'data context = {
+  name : string;
+  (** Element name (lowercase). *)
+  data : 'data;
+  (** Checker-specific data. *)
+}
+
+(** Ancestor tracker state. *)
+type 'data t
+
+(** {1 Creation} *)
+
+val create : unit -> 'data t
+(** [create ()] creates a new empty ancestor tracker. *)
+
+val reset : 'data t -> unit
+(** [reset tracker] clears all ancestor contexts from the tracker. *)
+
+(** {1 Stack Operations} *)
+
+val push : 'data t -> string -> 'data -> unit
+(** [push tracker name data] pushes a new element context onto the stack.
+
+    This should be called in [start_element] event handlers.
+
+    @param tracker The ancestor tracker
+    @param name The element name (will be lowercased)
+    @param data Checker-specific data to associate with this element *)
+
+val pop : 'data t -> unit
+(** [pop tracker] pops the most recent element context from the stack.
+
+    This should be called in [end_element] event handlers.
+
+    @param tracker The ancestor tracker *)
+
+val peek : 'data t -> 'data context option
+(** [peek tracker] returns the most recent element context without removing it.
+
+    @param tracker The ancestor tracker
+    @return [Some context] if the stack is non-empty, [None] otherwise *)
+
+val depth : 'data t -> int
+(** [depth tracker] returns the current stack depth (number of ancestors).
+
+    @param tracker The ancestor tracker
+    @return The number of elements on the stack *)
+
+(** {1 Ancestor Queries} *)
+
+val has_ancestor : 'data t -> string -> bool
+(** [has_ancestor tracker name] checks if an element with the given name
+    exists anywhere in the ancestor chain.
+
+    @param tracker The ancestor tracker
+    @param name The element name to search for (case-insensitive)
+    @return [true] if an ancestor with this name exists *)
+
+val has_ancestor_with : 'data t -> (string -> 'data -> bool) -> bool
+(** [has_ancestor_with tracker predicate] checks if any ancestor satisfies
+    the given predicate.
+
+    @param tracker The ancestor tracker
+    @param predicate Function that tests element name and data
+    @return [true] if any ancestor satisfies the predicate *)
+
+val find_ancestor : 'data t -> string -> 'data context option
+(** [find_ancestor tracker name] finds the nearest ancestor with the given name.
+
+    @param tracker The ancestor tracker
+    @param name The element name to search for (case-insensitive)
+    @return [Some context] for the nearest matching ancestor, [None] if not found *)
+
+val find_ancestor_with : 'data t -> (string -> 'data -> bool) -> 'data context option
+(** [find_ancestor_with tracker predicate] finds the nearest ancestor that
+    satisfies the predicate.
+
+    @param tracker The ancestor tracker
+    @param predicate Function that tests element name and data
+    @return [Some context] for the nearest matching ancestor, [None] if not found *)
+
+val get_all_ancestors : 'data t -> 'data context list
+(** [get_all_ancestors tracker] returns all ancestor contexts from nearest to root.
+
+    @param tracker The ancestor tracker
+    @return List of contexts, with the most recent first *)
+
+val filter_ancestors : 'data t -> (string -> 'data -> bool) -> 'data context list
+(** [filter_ancestors tracker predicate] returns all ancestors that satisfy
+    the predicate.
+
+    @param tracker The ancestor tracker
+    @param predicate Function that tests element name and data
+    @return List of matching contexts, from nearest to root *)
+
+val exists : 'data t -> (string -> 'data -> bool) -> bool
+(** [exists tracker predicate] checks if any ancestor satisfies the predicate.
+
+    This is an alias for {!has_ancestor_with}.
+
+    @param tracker The ancestor tracker
+    @param predicate Function that tests element name and data
+    @return [true] if any ancestor satisfies the predicate *)
+
+val for_all : 'data t -> (string -> 'data -> bool) -> bool
+(** [for_all tracker predicate] checks if all ancestors satisfy the predicate.
+
+    @param tracker The ancestor tracker
+    @param predicate Function that tests element name and data
+    @return [true] if all ancestors satisfy the predicate (vacuously true for empty stack) *)
+
+val iter : 'data t -> (string -> 'data -> unit) -> unit
+(** [iter tracker f] applies function [f] to each ancestor from nearest to root.
+
+    @param tracker The ancestor tracker
+    @param f Function to apply to each ancestor *)
+
+val fold : 'data t -> ('acc -> string -> 'data -> 'acc) -> 'acc -> 'acc
+(** [fold tracker f init] folds over ancestors from nearest to root.
+
+    @param tracker The ancestor tracker
+    @param f Folding function
+    @param init Initial accumulator value
+    @return Final accumulator value *)
+
+(** {1 Parent Access} *)
+
+val get_parent : 'data t -> 'data context option
+(** [get_parent tracker] returns the immediate parent element context.
+
+    This is equivalent to {!peek}.
+
+    @param tracker The ancestor tracker
+    @return [Some context] for the parent, [None] if at root *)
+
+val get_parent_name : 'data t -> string option
+(** [get_parent_name tracker] returns the immediate parent element name.
+
+    @param tracker The ancestor tracker
+    @return [Some name] for the parent, [None] if at root *)
+
+val get_parent_data : 'data t -> 'data option
+(** [get_parent_data tracker] returns the immediate parent's custom data.
+
+    @param tracker The ancestor tracker
+    @return [Some data] for the parent, [None] if at root *)
+
+(** {1 Multiple Ancestor Queries} *)
+
+val has_any_ancestor : 'data t -> string list -> bool
+(** [has_any_ancestor tracker names] checks if any of the given element names
+    exists in the ancestor chain.
+
+    @param tracker The ancestor tracker
+    @param names List of element names to search for
+    @return [true] if any name matches an ancestor *)
+
+val find_first_matching : 'data t -> string list -> (string * 'data context) option
+(** [find_first_matching tracker names] finds the nearest ancestor that matches
+    any of the given names.
+
+    @param tracker The ancestor tracker
+    @param names List of element names to search for
+    @return [Some (matched_name, context)] for the first match, [None] if no match *)
+
+(** {1 Stack Inspection} *)
+
+val is_empty : 'data t -> bool
+(** [is_empty tracker] checks if the stack is empty (at document root).
+
+    @param tracker The ancestor tracker
+    @return [true] if no elements are on the stack *)
+
+val to_list : 'data t -> 'data context list
+(** [to_list tracker] converts the stack to a list of contexts.
+
+    This is an alias for {!get_all_ancestors}.
+
+    @param tracker The ancestor tracker
+    @return List of contexts from nearest to root *)
+
+val to_name_list : 'data t -> string list
+(** [to_name_list tracker] returns just the element names in the stack.
+
+    @param tracker The ancestor tracker
+    @return List of element names from nearest to root *)

lib/check/attr_utils.ml

···
 type attrs = (string * string) list
 
 let has_attr name attrs =
-  List.exists (fun (n, _) -> String.lowercase_ascii n = name) attrs
+  List.exists (fun (n, _) -> Astring.String.Ascii.lowercase 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
+    if Astring.String.Ascii.lowercase n = name then Some v else None
   ) attrs
 
 let get_attr_or name ~default attrs =

lib/check/checker_registry.ml

···
   Hashtbl.replace reg "xhtml-content" Xhtml_content_checker.checker;
   Hashtbl.replace reg "lang-detecting" Lang_detecting_checker.checker;
   Hashtbl.replace reg "unknown-element" Unknown_element_checker.checker;
+  Hashtbl.replace reg "content" Content_checker.checker;
   reg
 
 let register registry name checker = Hashtbl.replace registry name checker

lib/check/content_model/content_checker.ml

···
       | Some spec ->
           List.exists (fun cat -> Element_spec.has_category spec cat) cats)
   | Content_model.Elements names ->
-      List.mem (String.lowercase_ascii element_name)
-        (List.map String.lowercase_ascii names)
+      List.mem (Astring.String.Ascii.lowercase element_name)
+        (List.map Astring.String.Ascii.lowercase names)
   | Content_model.Mixed cats -> (
       match Element_registry.get registry element_name with
       | None -> false
···
           (`Element (`Not_allowed_as_child (`Child name, `Parent prohibited))))
     spec.Element_spec.prohibited_ancestors
 
+(* Check if element is allowed via permitted_parents *)
+let is_permitted_parent registry child_name parent_name =
+  match Element_registry.get registry child_name with
+  | None -> false
+  | Some spec ->
+      match spec.Element_spec.permitted_parents with
+      | None -> false
+      | Some parents ->
+          List.mem (Astring.String.Ascii.lowercase parent_name)
+            (List.map Astring.String.Ascii.lowercase parents)
+
+(* Check if a specific element is in the ancestor stack *)
+let has_ancestor state ancestor_name =
+  List.exists (fun ctx ->
+    String.equal (Astring.String.Ascii.lowercase ctx.name)
+      (Astring.String.Ascii.lowercase ancestor_name)
+  ) state.ancestor_stack
+
+(* Check if an attribute exists in raw attrs list *)
+let has_raw_attr name attrs =
+  List.exists (fun (n, _) ->
+    Astring.String.Ascii.lowercase n = Astring.String.Ascii.lowercase name
+  ) attrs
+
+(* Special cases for content model validation:
+   - dt/dd inside div is only valid when dl is an ancestor (div as grouping in dl)
+   - meta with property/itemprop/name attribute in body is valid (RDFa/microdata)
+   - link with itemprop in body is valid (microdata) *)
+let is_special_case_allowed state child_name parent_name raw_attrs =
+  let child_lower = Astring.String.Ascii.lowercase child_name in
+  let parent_lower = Astring.String.Ascii.lowercase parent_name in
+  (* dt/dd inside div is allowed when dl is an ancestor *)
+  if (child_lower = "dt" || child_lower = "dd") && parent_lower = "div" then
+    has_ancestor state "dl"
+  (* meta in body is allowed with property (RDFa), itemprop (microdata), or name+content (meta tags) *)
+  else if child_lower = "meta" && parent_lower <> "head" then
+    has_raw_attr "property" raw_attrs ||
+    has_raw_attr "itemprop" raw_attrs ||
+    (has_raw_attr "name" raw_attrs && has_raw_attr "content" raw_attrs)
+  (* link in body is allowed with itemprop (microdata) or property (RDFa) *)
+  else if child_lower = "link" && parent_lower <> "head" then
+    has_raw_attr "itemprop" raw_attrs || has_raw_attr "property" raw_attrs
+  (* Custom elements (with hyphen) are valid HTML5 and are flow content *)
+  else if String.contains child_lower '-' then
+    true
+  else
+    false
+
 (* Validate that a child element is allowed *)
-let validate_child_element state child_name collector =
+let validate_child_element state child_name raw_attrs collector =
   match state.ancestor_stack with
   | [] ->
       (* Root level - only html allowed *)
-      if not (String.equal (String.lowercase_ascii child_name) "html") then
+      if not (String.equal (Astring.String.Ascii.lowercase child_name) "html") then
         Message_collector.add_typed collector
           (`Generic (Printf.sprintf "Element '%s' not allowed at document root (only 'html' allowed)" child_name))
   | parent :: _ ->
       let content_model = parent.spec.Element_spec.content_model in
-      if not (matches_content_model state.registry child_name content_model) then
+      (* Check content model, permitted_parents, or special cases *)
+      let allowed_by_content_model = matches_content_model state.registry child_name content_model in
+      let allowed_by_permitted_parents = is_permitted_parent state.registry child_name parent.name in
+      let allowed_by_special_case = is_special_case_allowed state child_name parent.name raw_attrs in
+      if not (allowed_by_content_model || allowed_by_permitted_parents || allowed_by_special_case) then
         Message_collector.add_typed collector
           (`Element (`Not_allowed_as_child (`Child child_name, `Parent parent.name)))
 
 let start_element state ~element collector =
   let name = Tag.tag_to_string element.Element.tag in
+  let raw_attrs = element.Element.raw_attrs in
 
   (* Check if we're inside a foreign (SVG/MathML) context *)
   let in_foreign_context = match state.ancestor_stack with
···
     match spec_opt with
     | None ->
         (* Unknown element - first check if it's allowed in current context *)
-        validate_child_element state name collector
+        validate_child_element state name raw_attrs collector;
+        (* Push unknown element onto stack with default flow content model *)
+        let spec = Element_spec.make ~name ~content_model:(Content_model.Categories [Content_category.Flow]) () in
+        let context = { name; spec; children_count = 0; is_foreign = false } in
+        state.ancestor_stack <- context :: state.ancestor_stack
     | Some spec ->
         (* Check prohibited ancestors *)
         check_prohibited_ancestors state name spec collector;
 
         (* Validate this element is allowed as child of parent *)
-        validate_child_element state name collector;
+        validate_child_element state name raw_attrs collector;
 
         (* Push element context onto stack *)
         let context = { name; spec; children_count = 0; is_foreign = false } in

lib/check/content_model/element_registry.ml

···
 let create () = Hashtbl.create 128
 
 let register registry spec =
-  let name = String.lowercase_ascii spec.Element_spec.name in
+  let name = Astring.String.Ascii.lowercase spec.Element_spec.name in
   Hashtbl.replace registry name spec
 
 let get registry name =
-  let name = String.lowercase_ascii name in
+  let name = Astring.String.Ascii.lowercase name in
   Hashtbl.find_opt registry name
 
 let list_names registry =

lib/check/content_model/elements_embedded.ml

···
     ()
 
 let img =
+  (* Note: img is only Interactive when it has usemap attribute;
+     we omit Interactive from static categories since usemap is rare *)
   Element_spec.make ~name:"img" ~void:true
-    ~categories:[ Flow; Phrasing; Embedded; Palpable; Interactive ]
+    ~categories:[ Flow; Phrasing; Embedded; Palpable ]
     ~content_model:Nothing
     ~attrs:
       [

lib/check/content_model/elements_form.ml

···
 let select =
   Element_spec.make ~name:"select"
     ~categories:[Flow; Phrasing; Interactive; Palpable]
-    ~content_model:(Elements ["option"; "optgroup"; "script"; "template"])
+    ~content_model:(Elements ["option"; "optgroup"; "hr"; "script"; "template"])
     ~attrs:[
       Attr_spec.make "autocomplete" ~datatype:"autocomplete" ();
       Attr_spec.make "disabled" ~datatype:"boolean" ();

lib/check/content_model/elements_table.ml

···
     ~categories:[]
     ~content_model:(Categories [ Flow ])
     ~permitted_parents:[ "table" ]
-    ~prohibited_ancestors:[ "table" ]
     ~attrs:[] ()
 
 let colgroup =

lib/check/datatype/datatype.ml

···
   | '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' -> true
   | _ -> false
 
-(** Case conversion *)
-
-let to_ascii_lowercase c =
-  match c with 'A' .. 'Z' -> Char.chr (Char.code c + 32) | _ -> c
+(** Case conversion - delegated to Astring *)
 
-let string_to_ascii_lowercase s =
-  String.map to_ascii_lowercase s
+(* Removed to_ascii_lowercase and string_to_ascii_lowercase - use Astring.String.Ascii.lowercase instead *)
 
 (** String predicates *)
 
···
 let make_enum ~name ~values ?(allow_empty = true) () : t =
   (* Pre-compute hashtable for O(1) membership *)
   let values_tbl = Hashtbl.create (List.length values) in
-  List.iter (fun v -> Hashtbl.add values_tbl (String.lowercase_ascii v) ()) values;
+  List.iter (fun v -> Hashtbl.add values_tbl (Astring.String.Ascii.lowercase v) ()) values;
   let values_str = String.concat ", " (List.map (Printf.sprintf "'%s'") values) in
   (module struct
     let name = name
     let validate s =
-      let s_lower = string_to_ascii_lowercase s in
+      let s_lower = Astring.String.Ascii.lowercase s in
       if (allow_empty && s = "") || Hashtbl.mem values_tbl s_lower then Ok ()
       else Error (Printf.sprintf "The value '%s' is not a valid %s value. Expected %s%s."
         s name (if allow_empty then "empty string, " else "") values_str)

lib/check/datatype/datatype.mli

···
 
 (** {2 Case conversion} *)
 
-(** Convert an ASCII character to lowercase. *)
-val to_ascii_lowercase : char -> char
-
-(** Convert an ASCII string to lowercase. *)
-val string_to_ascii_lowercase : string -> string
+(** Case conversion functions removed - use Astring.String.Ascii.lowercase instead *)
 
 (** {2 String predicates} *)
 

lib/check/datatype/dt_autocomplete.ml

···
 
 (* Use shared utilities from Datatype *)
 let is_whitespace = Datatype.is_whitespace
-let to_ascii_lowercase = Datatype.to_ascii_lowercase
+let to_ascii_lowercase c =
+  match c with 'A' .. 'Z' -> Char.chr (Char.code c + 32) | _ -> c
 
 (* Use Astring for string operations *)
 let is_prefix = Astring.String.is_prefix

lib/check/datatype/dt_boolean.ml

···
         match s with
         | "" | "true" | "false" -> Ok ()
         | _ ->
-            let s_lower = Datatype.string_to_ascii_lowercase s in
-            let attr_lower = Datatype.string_to_ascii_lowercase attr_name in
+            let s_lower = Astring.String.Ascii.lowercase s in
+            let attr_lower = Astring.String.Ascii.lowercase attr_name in
             if s_lower = attr_lower then Ok ()
             else
               Error

lib/check/datatype/dt_button_type.ml

···
   let name = "button-type"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_types then Ok ()
     else
       Error

lib/check/datatype/dt_charset.ml

···
   c = '\'' || c = '+' || c = '_' || c = '`' || c = '{' || c = '}' ||
   c = '~' || c = '^'
 
-let to_lower = Datatype.string_to_ascii_lowercase
+let to_lower = Astring.String.Ascii.lowercase
 
 (** Common encoding labels recognized by WHATWG Encoding Standard.
     This is a subset of the full list. *)

lib/check/datatype/dt_color.ml

···
   let name = "color"
 
   let validate s =
-    let s = String.trim s |> String.lowercase_ascii in
+    let s = String.trim s |> Astring.String.Ascii.lowercase in
     if String.length s = 0 then Error "Color value must not be empty"
     else if List.mem s named_colors then Ok ()
     else if String.length s > 0 && s.[0] = '#' then validate_hex_color s

lib/check/datatype/dt_contenteditable.ml

···
   let name = "contenteditable"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "true" | "false" | "plaintext-only" -> Ok ()
     | _ ->

lib/check/datatype/dt_crossorigin.ml

···
   let name = "crossorigin"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "anonymous" | "use-credentials" -> Ok ()
     | _ ->

lib/check/datatype/dt_decoding.ml

···
   let name = "decoding"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "sync" | "async" | "auto" -> Ok ()
     | _ ->

lib/check/datatype/dt_dir.ml

···
   let name = "dir"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "ltr" | "rtl" | "auto" -> Ok ()
     | _ ->

lib/check/datatype/dt_draggable.ml

···
   let name = "draggable"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "true" | "false" -> Ok ()
     | _ ->

lib/check/datatype/dt_enterkeyhint.ml

···
   let name = "enterkeyhint"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "enter" | "done" | "go" | "next" | "previous" | "search" | "send" ->
         Ok ()

lib/check/datatype/dt_fetchpriority.ml

···
   let name = "fetchpriority"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "high" | "low" | "auto" -> Ok ()
     | _ ->

lib/check/datatype/dt_form_enctype.ml

···
   let name = "form-enctype"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_enctypes then Ok ()
     else
       Error

lib/check/datatype/dt_form_method.ml

···
   let name = "form-method"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_methods then Ok ()
     else
       Error

lib/check/datatype/dt_hidden.ml

···
   let name = "hidden"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "hidden" | "until-found" -> Ok ()
     | _ ->

lib/check/datatype/dt_input_type.ml

···
   let name = "input-type"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_types then Ok ()
     else
       Error

lib/check/datatype/dt_inputmode.ml

···
   let name = "inputmode"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "none" | "text" | "decimal" | "numeric" | "tel" | "search"
     | "email" | "url" ->

lib/check/datatype/dt_integrity.ml

···
              "Hash value '%s' must be in format 'algorithm-base64hash'" trimmed)
     | Some dash_pos ->
         let algorithm = String.sub trimmed 0 dash_pos in
-        let algorithm_lower = Datatype.string_to_ascii_lowercase algorithm in
+        let algorithm_lower = Astring.String.Ascii.lowercase algorithm in
         if not (List.mem algorithm_lower valid_algorithms) then
           Error
             (Printf.sprintf

lib/check/datatype/dt_kind.ml

···
   let name = "kind"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "subtitles" | "captions" | "descriptions" | "chapters" | "metadata" -> Ok ()
     | _ ->

lib/check/datatype/dt_language.ml

···
 (* Use shared character predicates from Datatype *)
 let is_all_alpha = Datatype.is_all_alpha
 let is_all_alphanumeric = Datatype.is_all_alphanumeric
-let to_lower = Datatype.string_to_ascii_lowercase
+let to_lower = Astring.String.Ascii.lowercase
 
 (** Valid extlang subtags per IANA language-subtag-registry.
     Extlangs are 3-letter subtags that follow the primary language.

lib/check/datatype/dt_link_type.ml

···
   let trimmed = Datatype.trim_html_spaces s in
   if trimmed = "" then Error "Link type must not be empty"
   else
-    let lower = Datatype.string_to_ascii_lowercase trimmed in
+    let lower = Astring.String.Ascii.lowercase trimmed in
     if List.mem lower valid_link_types then Ok ()
     else
       Error

lib/check/datatype/dt_list_type.ml

···
   let name = "ul-type"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_ul_types then Ok ()
     else
       Error

lib/check/datatype/dt_loading.ml

···
   let name = "loading"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "lazy" | "eager" -> Ok ()
     | _ ->

lib/check/datatype/dt_media_query.ml

···
         let trimmed = String.trim s in
         if String.length trimmed >= 3 then begin
           let suffix = String.sub trimmed (String.length trimmed - 3) 3 in
-          if String.lowercase_ascii suffix = "and" then
+          if Astring.String.Ascii.lowercase suffix = "and" then
             Error "Parse Error."
           else if String.length trimmed >= 4 then begin
             let suffix4 = String.sub trimmed (String.length trimmed - 4) 4 in
-            if String.lowercase_ascii suffix4 = "and(" then
+            if Astring.String.Ascii.lowercase suffix4 = "and(" then
               Error "Parse Error."
             else
               validate_media_query_content trimmed
···
     let has_not = ref false in
     (match read_ident () with
     | Some w ->
-      let w_lower = String.lowercase_ascii w in
+      let w_lower = Astring.String.Ascii.lowercase w in
       if w_lower = "only" then (has_only := true; skip_ws ())
       else if w_lower = "not" then (has_not := true; skip_ws ())
       else i := !i - String.length w (* put back *)
···
               match read_ident () with
               | None -> Error "Parse Error."
               | Some kw ->
-                let kw_lower = String.lowercase_ascii kw in
+                let kw_lower = Astring.String.Ascii.lowercase kw in
                 if kw_lower <> "and" then Error "Parse Error."
                 else begin
                   (* Check that there was whitespace before 'and' *)
···
                             match read_ident () with
                             | None -> Error "Parse Error."
                             | Some kw2 ->
-                              let kw2_lower = String.lowercase_ascii kw2 in
+                              let kw2_lower = Astring.String.Ascii.lowercase kw2 in
                               if kw2_lower <> "and" then Error "Parse Error."
                               else begin
                                 skip_ws ();
···
     match String.index_opt content ':' with
     | None ->
       (* Just feature name - boolean feature or range syntax *)
-      let feature_lower = String.lowercase_ascii content in
+      let feature_lower = Astring.String.Ascii.lowercase content in
       if List.mem feature_lower deprecated_media_features then
         Error (Printf.sprintf "Deprecated media feature \"%s\". For guidance, see the Deprecated Media Features section in the current Media Queries specification." feature_lower)
       else if List.mem feature_lower valid_media_features then
···
     | Some colon_pos ->
       let feature = String.trim (String.sub content 0 colon_pos) in
       let value = String.trim (String.sub content (colon_pos + 1) (String.length content - colon_pos - 1)) in
-      let feature_lower = String.lowercase_ascii feature in
+      let feature_lower = Astring.String.Ascii.lowercase feature in
 
       (* Check for deprecated features *)
       if List.mem feature_lower deprecated_media_features then
···
     else if unit_part = "" then
       Error "only \"0\" can be a \"unit\". You must put a unit after your number"
     else begin
-      let unit_lower = String.lowercase_ascii unit_part in
+      let unit_lower = Astring.String.Ascii.lowercase 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 base_feature)

lib/check/datatype/dt_mime.ml

···
         if is_token_char c then parse In_subtype (i + 1)
         else if c = ';' then
           (* Check if this is a JavaScript MIME type *)
-          let mime_type = String.sub s 0 i |> String.lowercase_ascii in
+          let mime_type = String.sub s 0 i |> Astring.String.Ascii.lowercase in
           if List.mem mime_type javascript_mime_types then
             Error
               "A JavaScript MIME type must not contain any characters after \

lib/check/datatype/dt_popover.ml

···
   let name = "popover"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "auto" | "manual" -> Ok ()
     | _ ->

lib/check/datatype/dt_preload.ml

···
   let name = "preload"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_preloads then Ok ()
     else
       Error

lib/check/datatype/dt_referrer.ml

···
   let name = "referrerpolicy"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | ""
     | "no-referrer"

lib/check/datatype/dt_scope.ml

···
   let name = "scope"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_scopes then Ok ()
     else
       Error

lib/check/datatype/dt_shape.ml

···
   let name = "shape"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "default" | "rect" | "circle" | "poly" -> Ok ()
     | _ ->

lib/check/datatype/dt_spellcheck.ml

···
   let name = "spellcheck"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "true" | "false" -> Ok ()
     | _ ->

lib/check/datatype/dt_target.ml

···
   if String.length s = 0 then Error "Browsing context name must not be empty"
   else if s.[0] = '_' then
     (* If starts with underscore, must be a special keyword *)
-    let lower = Datatype.string_to_ascii_lowercase s in
+    let lower = Astring.String.Ascii.lowercase s in
     if List.mem lower special_keywords then Ok ()
     else
       Error

lib/check/datatype/dt_translate.ml

···
   let name = "translate"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     match s_lower with
     | "" | "yes" | "no" -> Ok ()
     | _ ->

lib/check/datatype/dt_url.ml

···
         match s.[i] with
         | ':' ->
             let scheme =
-              String.sub s start (i - start) |> Datatype.string_to_ascii_lowercase
+              String.sub s start (i - start) |> Astring.String.Ascii.lowercase
             in
             let rest = String.sub s (i + 1) (len - i - 1) in
             Some (scheme, rest)

lib/check/datatype/dt_wrap.ml

···
   let name = "wrap"
 
   let validate s =
-    let s_lower = Datatype.string_to_ascii_lowercase s in
+    let s_lower = Astring.String.Ascii.lowercase s in
     if List.mem s_lower valid_wraps then Ok ()
     else
       Error

lib/check/element/attr.ml

···
 
 (** Parse a single attribute name-value pair to typed attribute *)
 let parse_attr name value : t =
-  let name_lower = String.lowercase_ascii name in
-  let value_lower = String.lowercase_ascii value in
+  let name_lower = Astring.String.Ascii.lowercase name in
+  let value_lower = Astring.String.Ascii.lowercase value in
   match name_lower with
   (* Global attributes *)
   | "id" -> `Id value
···
 (** Get rel attribute as list of link types (space-separated, lowercased per HTML5 spec) *)
 let get_rel_list attrs =
   match get_rel attrs with
-  | Some s -> List.map String.lowercase_ascii (Datatype.split_on_whitespace s)
+  | Some s -> List.map Astring.String.Ascii.lowercase (Datatype.split_on_whitespace s)
   | None -> []
 
 (** Get headers attribute as raw string *)

lib/check/element/element.ml

···
 
 (** Parse element-specific type attribute based on tag *)
 let parse_type_attr (tag : Tag.html_tag) value : Attr.t =
-  let value_lower = String.lowercase_ascii value in
+  let value_lower = Astring.String.Ascii.lowercase value in
   match tag with
   | `Input ->
     (match Attr.parse_input_type value_lower with
···
 (** Parse attributes with element context for type attribute *)
 let parse_attrs_for_tag (tag : Tag.element_tag) (raw_attrs : (string * string) list) : Attr.t list =
   List.map (fun (name, value) ->
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
     if name_lower = "type" then
       match tag with
       | Tag.Html html_tag -> parse_type_attr html_tag value
···
 (** Get raw attribute value (from original attrs) *)
 let get_raw_attr name elem =
   List.find_map (fun (n, v) ->
-    if String.lowercase_ascii n = String.lowercase_ascii name then Some v else None
+    if Astring.String.Ascii.lowercase n = Astring.String.Ascii.lowercase name then Some v else None
   ) elem.raw_attrs
 
 (** Check if raw attribute exists *)
 let has_raw_attr name elem =
   List.exists (fun (n, _) ->
-    String.lowercase_ascii n = String.lowercase_ascii name
+    Astring.String.Ascii.lowercase n = Astring.String.Ascii.lowercase name
   ) elem.raw_attrs
 
 (** {1 Pattern Matching Helpers} *)

lib/check/element/tag.ml

···
 (** Check if a name is a valid custom element name (contains hyphen, not reserved) *)
 let is_custom_element_name name =
   String.contains name '-' &&
-  not (String.starts_with ~prefix:"xml" (String.lowercase_ascii name)) &&
-  not (String.equal (String.lowercase_ascii name) "annotation-xml")
+  not (String.starts_with ~prefix:"xml" (Astring.String.Ascii.lowercase name)) &&
+  not (String.equal (Astring.String.Ascii.lowercase name) "annotation-xml")
 
 (** SVG namespace URI *)
 let svg_namespace = "http://www.w3.org/2000/svg"
···
 
 (** Convert tag name and optional namespace to element_tag *)
 let tag_of_string ?namespace name =
-  let name_lower = String.lowercase_ascii name in
+  let name_lower = Astring.String.Ascii.lowercase name in
   match namespace with
   | Some ns when is_svg_namespace ns -> Svg name  (* Preserve original case for SVG *)
   | Some ns when is_mathml_namespace ns -> MathML name  (* Preserve original case for MathML *)

lib/check/semantic/form_checker.ml

···
 
 (** Check if autocomplete value contains webauthn token *)
 let contains_webauthn value =
-  let lower = String.lowercase_ascii value in
+  let lower = Astring.String.Ascii.lowercase value in
   let tokens = String.split_on_char ' ' lower |> List.filter (fun s -> String.length s > 0) in
   List.mem "webauthn" tokens
 

lib/check/semantic/lang_detecting_checker.ml

···
 let get_lang_code lang =
   (* Extract primary language subtag *)
   match String.split_on_char '-' lang with
-  | code :: _ -> String.lowercase_ascii code
+  | code :: _ -> Astring.String.Ascii.lowercase code
   | [] -> ""
 
 (* Create detector lazily with deterministic seed *)
···
           | None ->
               Message_collector.add_typed collector
                 (`I18n (`Missing_dir_rtl (`Language detected_name)))
-          | Some dir when String.lowercase_ascii dir <> "rtl" ->
+          | Some dir when Astring.String.Ascii.lowercase dir <> "rtl" ->
               Message_collector.add_typed collector
                 (`I18n (`Wrong_dir (`Language detected_name, `Declared dir)))
           | _ -> ()

lib/check/semantic/nesting_checker.ml

···
   state.ancestor_flags <- empty_flags ()
 
 (** Get attribute value by name from attribute list. *)
-let get_attr attrs name =
-  List.assoc_opt name attrs
+let get_attr = Attr_utils.get_attr
 
 (** Check if an attribute exists. *)
-let has_attr attrs name =
-  get_attr attrs name <> None
+let has_attr = Attr_utils.has_attr
 
 (** Check if element is interactive based on its attributes. *)
 let is_interactive_element name attrs =
   match name with
-  | "a" -> has_attr attrs "href"
-  | "audio" | "video" -> has_attr attrs "controls"
-  | "img" | "object" -> has_attr attrs "usemap"
+  | "a" -> has_attr "href" attrs
+  | "audio" | "video" -> has_attr "controls" attrs
+  | "img" | "object" -> has_attr "usemap" attrs
   | "input" ->
-      (match get_attr attrs "type" with
+      (match get_attr "type" attrs with
        | Some "hidden" -> false
        | _ -> true)
   | "button" | "details" | "embed" | "iframe" | "label" | "select"
···
   (* Determine attribute to mention in error messages *)
   let attr =
     match name with
-    | "a" when has_attr attrs "href" -> Some "href"
-    | "audio" when has_attr attrs "controls" -> Some "controls"
-    | "video" when has_attr attrs "controls" -> Some "controls"
-    | "img" when has_attr attrs "usemap" -> Some "usemap"
-    | "object" when has_attr attrs "usemap" -> Some "usemap"
+    | "a" when has_attr "href" attrs -> Some "href"
+    | "audio" when has_attr "controls" attrs -> Some "controls"
+    | "video" when has_attr "controls" attrs -> Some "controls"
+    | "img" when has_attr "usemap" attrs -> Some "usemap"
+    | "object" when has_attr "usemap" attrs -> Some "usemap"
     | _ -> None
   in
 

lib/check/semantic/obsolete_checker.ml

···
   match element.Element.tag with
   | Tag.Html _ ->
     let name = Tag.tag_to_string element.tag in
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
     let attrs = element.raw_attrs in
 
     (* Track head context *)
···
 
     (* Check for obsolete attributes *)
     List.iter (fun (attr_name, _attr_value) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
 
       (* Special handling for scoped attribute on style *)
       if attr_lower = "scoped" && name_lower = "style" then begin

lib/check/semantic/required_attr_checker.ml

···
   (* popover attribute must have valid value *)
   match Attr_utils.get_attr "popover" attrs with
   | Some value ->
-    let value_lower = String.lowercase_ascii value in
+    let value_lower = Astring.String.Ascii.lowercase value in
     (* Valid values: empty string, auto, manual, hint *)
     if value_lower <> "" && value_lower <> "auto" && value_lower <> "manual" && value_lower <> "hint" then
       Message_collector.add_typed collector

lib/check/specialized/aria_checker.ml

···
   else
     String.split_on_char ' ' trimmed
     |> List.filter (fun s -> String.trim s <> "")
-    |> List.map String.lowercase_ascii
+    |> List.map Astring.String.Ascii.lowercase
 
 (** Get the implicit role for an HTML element. *)
 let get_implicit_role element_name attrs =
   (* Check for input element with type attribute *)
   if element_name = "input" then begin
-    match List.assoc_opt "type" attrs with
+    match Attr_utils.get_attr "type" attrs with
     | Some input_type ->
-        let input_type = String.lowercase_ascii input_type in
+        let input_type = Astring.String.Ascii.lowercase input_type in
         begin match Hashtbl.find_opt input_types_with_implicit_role input_type with
         | Some role -> Some role
         | None ->
···
   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
+    match Attr_utils.get_attr "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
+    match Attr_utils.get_attr "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
···
   match element.Element.tag with
   | Tag.Html _ ->
       let name = Tag.tag_to_string element.tag in
-      let name_lower = String.lowercase_ascii name in
+      let name_lower = Astring.String.Ascii.lowercase name in
       let attrs = element.raw_attrs in
-      let role_attr = List.assoc_opt "role" attrs in
-      let aria_label = List.assoc_opt "aria-label" attrs in
-      let aria_labelledby = List.assoc_opt "aria-labelledby" attrs in
-      let aria_braillelabel = List.assoc_opt "aria-braillelabel" attrs in
+      let role_attr = Attr_utils.get_attr "role" attrs in
+      let aria_label = Attr_utils.get_attr "aria-label" attrs in
+      let aria_labelledby = Attr_utils.get_attr "aria-labelledby" attrs in
+      let aria_braillelabel = Attr_utils.get_attr "aria-braillelabel" attrs in
       let has_aria_label = match aria_label with Some v -> String.trim v <> "" | None -> false in
       let has_aria_labelledby = match aria_labelledby with Some v -> String.trim v <> "" | None -> false in
       let has_aria_braillelabel = match aria_braillelabel with Some v -> String.trim v <> "" | None -> false in
···
 
       (* Track active tabs and tabpanel roles for end_document validation *)
       if List.mem "tab" explicit_roles then begin
-        let aria_selected = List.assoc_opt "aria-selected" attrs in
+        let aria_selected = Attr_utils.get_attr "aria-selected" attrs in
         if aria_selected = Some "true" then state.has_active_tab <- true
       end;
       if List.mem "tabpanel" explicit_roles then state.has_tabpanel <- true;
 
       (* Track visible main elements (explicit role=main or implicit main role) *)
       let is_hidden =
-        let aria_hidden = List.assoc_opt "aria-hidden" attrs in
+        let aria_hidden = Attr_utils.get_attr "aria-hidden" attrs in
         aria_hidden = Some "true"
       in
       if not is_hidden then begin
···
       (* Check br/wbr aria-* attribute restrictions - not allowed *)
       if name_lower = "br" || name_lower = "wbr" then begin
         List.iter (fun (attr_name, _) ->
-          let attr_lower = String.lowercase_ascii attr_name in
+          let attr_lower = Astring.String.Ascii.lowercase attr_name in
           if String.starts_with ~prefix:"aria-" attr_lower &&
              attr_lower <> "aria-hidden" then
             Message_collector.add_typed collector
···
 
       (* Check for img with empty alt having role attribute *)
       if name_lower = "img" then begin
-        let alt_value = List.assoc_opt "alt" attrs in
+        let alt_value = Attr_utils.get_attr "alt" attrs in
         match alt_value with
         | Some alt when String.trim alt = "" ->
           (* img with empty alt must not have role attribute *)
···
 
       (* Check for input[type=checkbox][role=button] requires aria-pressed *)
       if name_lower = "input" then begin
-        let input_type = match List.assoc_opt "type" attrs with
-          | Some t -> String.lowercase_ascii t
+        let input_type = match Attr_utils.get_attr "type" attrs with
+          | Some t -> Astring.String.Ascii.lowercase t
           | None -> "text"
         in
         if input_type = "checkbox" && List.mem "button" explicit_roles then begin
-          let has_aria_pressed = List.assoc_opt "aria-pressed" attrs <> None in
+          let has_aria_pressed = Attr_utils.has_attr "aria-pressed" attrs in
           if not has_aria_pressed then
             Message_collector.add_typed collector (`Input `Checkbox_needs_aria_pressed)
         end
···
 
       (* Check for aria-hidden="true" on body element *)
       if name_lower = "body" then begin
-        let aria_hidden = List.assoc_opt "aria-hidden" attrs in
+        let aria_hidden = Attr_utils.get_attr "aria-hidden" attrs in
         match aria_hidden with
         | Some "true" ->
           Message_collector.add_typed collector (`Aria `Hidden_on_body)
···
       end;
 
       (* Check for aria-checked on input[type=checkbox] *)
-      let aria_checked = List.assoc_opt "aria-checked" attrs in
+      let aria_checked = Attr_utils.get_attr "aria-checked" attrs in
       if name_lower = "input" then begin
-        match List.assoc_opt "type" attrs with
-        | Some input_type when String.lowercase_ascii input_type = "checkbox" ->
+        match Attr_utils.get_attr "type" attrs with
+        | Some input_type when Astring.String.Ascii.lowercase input_type = "checkbox" ->
           if aria_checked <> None then
             Message_collector.add_typed collector
               (`Aria (`Must_not_use (`Attr "aria-checked", `Elem "input",
···
       end;
 
       (* Check for aria-expanded on roles that don't support it *)
-      let aria_expanded = List.assoc_opt "aria-expanded" attrs in
+      let aria_expanded = Attr_utils.get_attr "aria-expanded" attrs in
       if aria_expanded <> None then begin
         let role_to_check = match explicit_roles with
           | first :: _ -> Some first
···
         (* Special message for input[type=text] with role="textbox" *)
         let reason =
           if name_lower = "input" && first_role = "textbox" then begin
-            let has_list = List.exists (fun (k, _) -> String.lowercase_ascii k = "list") attrs in
-            let input_type = match List.assoc_opt "type" attrs with
-              | Some t -> String.lowercase_ascii t
+            let has_list = Attr_utils.has_attr "list" attrs in
+            let input_type = match Attr_utils.get_attr "type" attrs with
+              | Some t -> Astring.String.Ascii.lowercase t
               | None -> "text"
             in
             if not has_list && input_type = "text" then
···
 
       (* Check for redundant default ARIA attribute values *)
       List.iter (fun (attr_name, attr_value) ->
-        let attr_lower = String.lowercase_ascii attr_name in
+        let attr_lower = Astring.String.Ascii.lowercase attr_name in
         if String.starts_with ~prefix:"aria-" attr_lower then
           match Hashtbl.find_opt aria_default_values attr_lower with
           | Some default_value ->
-              let value_lower = String.lowercase_ascii (String.trim attr_value) in
+              let value_lower = Astring.String.Ascii.lowercase (String.trim attr_value) in
               if value_lower = default_value then
                 Message_collector.add_typed collector
                   (`Generic (Printf.sprintf
···
       if name_lower = "summary" then begin
         let parent = get_parent_element state in
         let is_in_details = parent = Some "details" in
-        let has_role_attr = List.exists (fun (k, _) -> String.lowercase_ascii k = "role") attrs in
-        let has_aria_expanded = List.assoc_opt "aria-expanded" attrs <> None in
-        let has_aria_pressed = List.assoc_opt "aria-pressed" attrs <> None in
+        let has_role_attr = Attr_utils.has_attr "role" attrs in
+        let has_aria_expanded = Attr_utils.has_attr "aria-expanded" attrs in
+        let has_aria_pressed = Attr_utils.has_attr "aria-pressed" attrs in
         if is_in_details then begin
           (* summary that is the first child of details *)
           if has_role_attr then
···
       (* Custom elements (autonomous custom elements) have generic role by default
          and cannot have accessible names unless they have an explicit role *)
       let attrs = element.raw_attrs in
-      let role_attr = List.assoc_opt "role" attrs in
-      let aria_label = List.assoc_opt "aria-label" attrs in
-      let aria_labelledby = List.assoc_opt "aria-labelledby" attrs in
-      let aria_braillelabel = List.assoc_opt "aria-braillelabel" attrs in
+      let role_attr = Attr_utils.get_attr "role" attrs in
+      let aria_label = Attr_utils.get_attr "aria-label" attrs in
+      let aria_labelledby = Attr_utils.get_attr "aria-labelledby" attrs in
+      let aria_braillelabel = Attr_utils.get_attr "aria-braillelabel" attrs in
       let has_aria_label = match aria_label with Some v -> String.trim v <> "" | None -> false in
       let has_aria_labelledby = match aria_labelledby with Some v -> String.trim v <> "" | None -> false in
       let has_aria_braillelabel = match aria_braillelabel with Some v -> String.trim v <> "" | None -> false in

lib/check/specialized/attr_restrictions_checker.ml

···
   match element.Element.tag with
   | Tag.Html _ ->
     let name = Tag.tag_to_string element.tag in
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
     let attrs = element.raw_attrs in
 
     (* Detect XHTML mode from xmlns attribute on html element *)
···
     (* Check for xmlns:* prefixed attributes - not allowed in HTML *)
     (* Standard xmlns declarations are allowed but custom prefixes are not *)
     List.iter (fun (attr_name, _) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       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 *)
···
     (* Validate style type attribute - must be "text/css" or omitted *)
     if name_lower = "style" then begin
       List.iter (fun (attr_name, attr_value) ->
-        let attr_lower = String.lowercase_ascii attr_name in
+        let attr_lower = Astring.String.Ascii.lowercase attr_name in
         if attr_lower = "type" then begin
-          let value_lower = String.lowercase_ascii (String.trim attr_value) in
+          let value_lower = Astring.String.Ascii.lowercase (String.trim attr_value) in
           if value_lower <> "text/css" then
             Message_collector.add_typed collector (`Misc `Style_type_invalid)
         end
···
       (* imagesrcset requires as="image" *)
       if has_imagesrcset then begin
         let as_is_image = match as_value with
-          | Some v -> String.lowercase_ascii (String.trim v) = "image"
+          | Some v -> Astring.String.Ascii.lowercase (String.trim v) = "image"
           | None -> false
         in
         if not as_is_image then
···
     (* Validate img usemap attribute - must be hash-name reference with content *)
     if name_lower = "img" then begin
       List.iter (fun (attr_name, attr_value) ->
-        let attr_lower = String.lowercase_ascii attr_name in
+        let attr_lower = Astring.String.Ascii.lowercase attr_name in
         if attr_lower = "usemap" then begin
           if attr_value = "#" then
             Message_collector.add_typed collector
···
     (* Validate embed type attribute - must be valid MIME type *)
     if name_lower = "embed" then begin
       List.iter (fun (attr_name, attr_value) ->
-        let attr_lower = String.lowercase_ascii attr_name in
+        let attr_lower = Astring.String.Ascii.lowercase attr_name in
         if attr_lower = "type" then begin
           match Dt_mime.validate_mime_type attr_value with
           | Ok () -> ()
···
                                name_lower = "iframe" || name_lower = "source" in
     if is_dimension_element then begin
       List.iter (fun (attr_name, attr_value) ->
-        let attr_lower = String.lowercase_ascii attr_name in
+        let attr_lower = Astring.String.Ascii.lowercase attr_name in
         if attr_lower = "width" || attr_lower = "height" then begin
           (* Check for non-negative integer only *)
           let is_valid =
···
     (* Validate area[shape=default] cannot have coords *)
     if name_lower = "area" then begin
       match Attr_utils.get_attr "shape" attrs with
-      | Some s when String.lowercase_ascii (String.trim s) = "default" ->
+      | Some s when Astring.String.Ascii.lowercase (String.trim s) = "default" ->
         if Attr_utils.has_attr "coords" attrs then
           Message_collector.add_typed collector
             (`Attr (`Not_allowed (`Attr "coords", `Elem "area")))
···
       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" ->
+      | Some v when Astring.String.Ascii.lowercase (String.trim v) = "auto" ->
         Message_collector.add_typed collector (`Misc `Bdo_dir_auto)
       | _ -> ()
     end;
···
     if name_lower = "input" then begin
       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
+                         |> String.trim |> Astring.String.Ascii.lowercase in
         if not (List.mem input_type input_types_allowing_list) then
           Message_collector.add_typed collector (`Input `List_not_allowed)
       end
···
 
     (* Validate data-* attributes *)
     List.iter (fun (attr_name, _) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       (* Check if it starts with "data-" *)
       if String.starts_with ~prefix:"data-" attr_lower then begin
         let after_prefix = String.sub attr_lower 5 (String.length attr_lower - 5) in
···
         (match lang_value with
          | None ->
            Message_collector.add_typed collector (`I18n `Xml_lang_without_lang)
-         | Some lang when String.lowercase_ascii lang <> String.lowercase_ascii xmllang ->
+         | Some lang when Astring.String.Ascii.lowercase lang <> Astring.String.Ascii.lowercase xmllang ->
            Message_collector.add_typed collector (`I18n `Xml_lang_without_lang)
          | _ -> ())
       | None -> ()
···
 
     (* Validate spellcheck attribute - must be "true" or "false" or empty *)
     List.iter (fun (attr_name, attr_value) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       if attr_lower = "spellcheck" then begin
-        let value_lower = String.lowercase_ascii (String.trim attr_value) in
+        let value_lower = Astring.String.Ascii.lowercase (String.trim attr_value) in
         if value_lower <> "" && value_lower <> "true" && value_lower <> "false" then
           Message_collector.add_typed collector
             (`Attr (`Bad_value (`Elem name, `Attr attr_name, `Value attr_value, `Reason "")))
···
     (* Validate enterkeyhint attribute - must be one of specific values *)
     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
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       if attr_lower = "enterkeyhint" then begin
-        let value_lower = String.lowercase_ascii (String.trim attr_value) in
+        let value_lower = Astring.String.Ascii.lowercase (String.trim attr_value) in
         if not (List.mem value_lower valid_enterkeyhint) then
           Message_collector.add_typed collector
             (`Attr (`Bad_value (`Elem name, `Attr attr_name, `Value attr_value, `Reason "")))
···
 
     (* Validate headingoffset attribute - must be a number between 0 and 8 *)
     List.iter (fun (attr_name, attr_value) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       if attr_lower = "headingoffset" then begin
         let trimmed = String.trim attr_value in
         let is_valid =
···
 
     (* Validate accesskey attribute - each key label must be a single code point *)
     List.iter (fun (attr_name, attr_value) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       if attr_lower = "accesskey" then begin
         (* Split by whitespace to get key labels *)
         let keys = String.split_on_char ' ' attr_value |>
···
     let is_media_element = name_lower = "link" || name_lower = "style" || name_lower = "source" in
     if is_media_element then begin
       List.iter (fun (attr_name, attr_value) ->
-        let attr_lower = String.lowercase_ascii attr_name in
+        let attr_lower = Astring.String.Ascii.lowercase attr_name in
         if attr_lower = "media" then begin
           let trimmed = String.trim attr_value in
           if trimmed <> "" then begin
···
 
     (* Validate RDFa prefix attribute - space-separated list of prefix:iri pairs *)
     List.iter (fun (attr_name, attr_value) ->
-      let attr_lower = String.lowercase_ascii attr_name in
+      let attr_lower = Astring.String.Ascii.lowercase attr_name in
       if attr_lower = "prefix" then begin
         (* Parse prefix attribute value - format: "prefix1: iri1 prefix2: iri2 ..." *)
         let trimmed = String.trim attr_value in

lib/check/specialized/datetime_checker.ml

···
     if List.mem name datetime_elements then begin
       (* Check for datetime attribute *)
       let datetime_attr = List.find_map (fun (k, v) ->
-        if String.lowercase_ascii k = "datetime" then Some v else None
+        if Astring.String.Ascii.lowercase k = "datetime" then Some v else None
       ) element.raw_attrs in
       match datetime_attr with
       | None -> ()

lib/check/specialized/dl_checker.ml

···
            (`Element (`Not_allowed_as_child (`Child "div", `Parent "dl")));
        (match Attr.get_role element.attrs with
         | Some role_value ->
-          let role_lower = String.lowercase_ascii (String.trim role_value) in
+          let role_lower = Astring.String.Ascii.lowercase (String.trim role_value) in
           if role_lower <> "presentation" && role_lower <> "none" then
             Message_collector.add_typed collector (`Li_role `Div_in_dl_bad_role)
         | None -> ());

lib/check/specialized/importmap_checker.ml

···
   | Tag.Html `Script ->
     (* Check if type="importmap" *)
     let type_attr = List.find_opt (fun (n, _) ->
-      String.lowercase_ascii n = "type"
+      Astring.String.Ascii.lowercase n = "type"
     ) element.raw_attrs in
     (match type_attr with
-     | Some (_, v) when String.lowercase_ascii v = "importmap" ->
+     | Some (_, v) when Astring.String.Ascii.lowercase v = "importmap" ->
        state.in_importmap <- true;
        Buffer.clear state.content
      | _ -> ())

lib/check/specialized/label_checker.ml

···
     | _ -> ())
 
   | Tag.Html tag ->
-    let name_lower = String.lowercase_ascii (Tag.tag_to_string (Tag.Html tag)) in
+    let name_lower = Astring.String.Ascii.lowercase (Tag.tag_to_string (Tag.Html tag)) in
 
     (* Track labelable element IDs *)
     (if is_labelable name_lower then

lib/check/specialized/language_checker.ml

···
 
 (** Check if a language tag contains deprecated subtags. *)
 let check_deprecated_tag value =
-  let lower = String.lowercase_ascii value in
+  let lower = Astring.String.Ascii.lowercase value in
   let subtags = String.split_on_char '-' lower in
   match subtags with
   | [] -> None

lib/check/specialized/mime_type_checker.ml

···
 let create () = ()
 let reset _state = ()
 
-let get_attr_value name attrs =
-  List.find_map (fun (k, v) ->
-    if String.lowercase_ascii k = String.lowercase_ascii name then Some v else None
-  ) attrs
+let get_attr_value = Attr_utils.get_attr
 
 let start_element _state ~element collector =
   match element.Element.tag with
   | Tag.Html tag ->
     let name = Tag.html_tag_to_string tag in
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
     (match List.assoc_opt name_lower mime_type_attrs with
     | None -> ()
     | Some type_attrs ->
···
           if value = "" then ()
           else if name_lower = "script" then
             (* script type can be module, importmap, etc. - skip validation for non-MIME types *)
-            let value_lower = String.lowercase_ascii value in
+            let value_lower = Astring.String.Ascii.lowercase value in
             if value_lower = "module" || value_lower = "importmap" ||
                not (String.contains value '/') then ()
             else

lib/check/specialized/picture_checker.ml

···
      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"
+       | Some v -> Astring.String.Ascii.lowercase (String.trim v) = "all"
        | None -> false in
      let is_media_empty = match media_value with
        | Some v -> String.trim v = ""
···
        | None -> not has_type
        | Some v ->
          let trimmed = String.trim v in
-         trimmed = "" || String.lowercase_ascii trimmed = "all"
+         trimmed = "" || Astring.String.Ascii.lowercase trimmed = "all"
      in
      if is_always_matching then begin
        state.has_always_matching_source <- true;

lib/check/specialized/srcset_sizes_checker.ml

···
 
 (** Check if scientific notation has invalid exponent (like 1e+1.5 - decimal in exponent) *)
 let has_invalid_scientific_notation s =
-  let lower = String.lowercase_ascii s in
+  let lower = Astring.String.Ascii.lowercase s in
   (* Find 'e' for scientific notation *)
   match String.index_opt lower 'e' with
   | None -> false
···
   (* Check for % at the end *)
   else if trimmed.[len - 1] = '%' then "%"
   else begin
-    let lower = String.lowercase_ascii trimmed in
+    let lower = Astring.String.Ascii.lowercase trimmed in
     (* Try to find a unit at the end (letters only) *)
     let rec find_unit_length i =
       if i < 0 then 0
···
     if has_invalid_scientific_notation value_no_comments then BadScientificNotation
     (* "auto" is only valid with lazy loading, which requires checking the element context.
        For general validation, treat "auto" alone as invalid in sizes. *)
-    else if String.lowercase_ascii value_no_comments = "auto" then
+    else if Astring.String.Ascii.lowercase value_no_comments = "auto" then
       BadCssNumber (value_no_comments.[0], trimmed)
     else if value_no_comments = "" then InvalidUnit ("", trimmed)
     else begin
-      let lower = String.lowercase_ascii value_no_comments in
+      let lower = Astring.String.Ascii.lowercase value_no_comments in
       (* Check for calc() or other CSS functions first - these are always valid *)
       if String.contains value_no_comments '(' then Valid
       else begin
···
           Some "Bad media condition: Parse Error"
     end else begin
       (* Check for bare "all" which is invalid *)
-      let lower = String.lowercase_ascii trimmed in
+      let lower = Astring.String.Ascii.lowercase trimmed in
       let parts = String.split_on_char ' ' lower |> List.filter (fun s -> s <> "") in
       match parts with
       | keyword :: _ when keyword = "all" ->
···
           end
           else begin
             (* Check if remaining starts with "and", "or", "not" followed by space or paren *)
-            let lower_remaining = String.lowercase_ascii remaining in
+            let lower_remaining = Astring.String.Ascii.lowercase remaining in
             if remaining_len >= 4 && String.sub lower_remaining 0 4 = "and " then
               skip_media_condition (i + (len - i) - remaining_len + 4)
             else if remaining_len >= 3 && String.sub lower_remaining 0 3 = "or " then
···
 
 (** Validate srcset descriptor *)
 let validate_srcset_descriptor desc element_name srcset_value has_sizes collector =
-  let desc_lower = String.lowercase_ascii (String.trim desc) in
+  let desc_lower = Astring.String.Ascii.lowercase (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
···
 
 (** Normalize descriptor for duplicate detection (e.g., 1x = 1.0x) *)
 let normalize_descriptor desc =
-  let desc_lower = String.lowercase_ascii (String.trim desc) in
+  let desc_lower = Astring.String.Ascii.lowercase (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
···
         (* Special schemes that require host/content after :// *)
         let special_schemes = ["http"; "https"; "ftp"; "ws"; "wss"] in
         (* Check for scheme-only URL like "http:" *)
-        let url_lower = String.lowercase_ascii url in
+        let url_lower = Astring.String.Ascii.lowercase url in
         List.iter (fun scheme ->
           let scheme_colon = scheme ^ ":" in
           if url_lower = scheme_colon then
···
             (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected single descriptor but found extraneous descriptor %s at %s." (q value) (q "srcset") (q element_name) (q extra_desc) (q value)))))
         end;
 
-        let desc_lower = String.lowercase_ascii (String.trim desc) in
+        let desc_lower = Astring.String.Ascii.lowercase (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
···
           begin match Hashtbl.find_opt seen_descriptors normalized with
           | Some first_url ->
             Message_collector.add_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: %s for image %s is identical to %s for image %s." (q value) (q "srcset") (q element_name) dup_type (q url) (String.lowercase_ascii dup_type) (q first_url)))))
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: %s for image %s is identical to %s for image %s." (q value) (q "srcset") (q element_name) dup_type (q url) (Astring.String.Ascii.lowercase dup_type) (q first_url)))))
           | None ->
             begin match (if is_1x then Hashtbl.find_opt seen_descriptors "implicit-1x" else None) with
             | Some first_url ->
               (* Explicit 1x conflicts with implicit 1x *)
               Message_collector.add_typed collector
-                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: %s for image %s is identical to %s for image %s." (q value) (q "srcset") (q element_name) dup_type (q url) (String.lowercase_ascii dup_type) (q first_url)))))
+                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: %s for image %s is identical to %s for image %s." (q value) (q "srcset") (q element_name) dup_type (q url) (Astring.String.Ascii.lowercase dup_type) (q first_url)))))
             | None ->
               Hashtbl.add seen_descriptors normalized url;
               if is_1x then Hashtbl.add seen_descriptors "explicit-1x" url

lib/check/specialized/svg_checker.ml

···
 
 (* Check if attribute name matches a pattern like "data-*" or "aria-*" - case insensitive *)
 let matches_pattern attr pattern =
-  let attr_lower = String.lowercase_ascii attr in
-  let pattern_lower = String.lowercase_ascii pattern in
+  let attr_lower = Astring.String.Ascii.lowercase attr in
+  let pattern_lower = Astring.String.Ascii.lowercase pattern in
   if String.ends_with ~suffix:"-*" pattern_lower then
     let prefix = String.sub pattern_lower 0 (String.length pattern_lower - 1) in
     String.starts_with ~prefix attr_lower
···
     state.in_svg <- true;
 
   if is_svg_element || state.in_svg then begin
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
 
     (* Check SVG content model rules *)
     (* 1. Check if child is allowed in SVG <a> *)
     (match state.element_stack with
-    | parent :: _ when String.lowercase_ascii parent = "a" ->
+    | parent :: _ when Astring.String.Ascii.lowercase parent = "a" ->
         if List.mem name_lower a_disallowed_children then
           Message_collector.add_typed collector
             (`Element (`Not_allowed_as_child (`Child name, `Parent "a")))
···
     (* 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
+      | parent :: _ when (let p = Astring.String.Ascii.lowercase parent in
                           p = "lineargradient" || p = "radialgradient") -> ()
       | parent :: _ ->
           Message_collector.add_typed collector
···
     (* 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" ->
+      | parent :: _ when Astring.String.Ascii.lowercase parent = "use" ->
           Message_collector.add_typed collector
             (`Element (`Not_allowed_as_child (`Child name, `Parent parent)))
       | _ -> ()
···
 
     (* 3. Check duplicate feFunc* in feComponentTransfer *)
     (match state.element_stack with
-    | parent :: _ when String.lowercase_ascii parent = "fecomponenttransfer" ->
+    | parent :: _ when Astring.String.Ascii.lowercase parent = "fecomponenttransfer" ->
         if List.mem name_lower ["fefuncr"; "fefuncg"; "fefuncb"; "fefunca"] then begin
           match state.fecomponenttransfer_stack with
           | fect :: _ ->
···
 
     (* Check each attribute *)
     List.iter (fun (attr, value) ->
-      let attr_lower = String.lowercase_ascii attr in
+      let attr_lower = Astring.String.Ascii.lowercase attr in
 
       (* Validate xmlns attributes *)
       if String.starts_with ~prefix:"xmlns" attr_lower then
···
     (match List.assoc_opt name_lower required_attrs with
     | Some req_attrs ->
         List.iter (fun req_attr ->
-          if not (List.exists (fun (a, _) -> String.lowercase_ascii a = req_attr) attrs) then
+          if not (Attr_utils.has_attr req_attr attrs) then
             Message_collector.add_typed collector
               (`Svg (`Missing_attr (`Elem name_lower, `Attr req_attr)))
         ) req_attrs
···
   let name = Tag.tag_to_string tag in
 
   if is_svg_element || state.in_svg then begin
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
 
     (* Check required children when closing font element *)
     if name_lower = "font" then begin

lib/check/specialized/table_checker.ml

···
 
 (** Parse a non-negative integer attribute, returning 1 if absent or invalid *)
 let parse_non_negative_int attrs name =
-  match List.assoc_opt name attrs with
+  match Attr_utils.get_attr name attrs with
   | None -> 1
   | Some v -> (
       try
···
 
 (** Parse a positive integer attribute, returning 1 if absent or invalid *)
 let parse_positive_int attrs name =
-  match List.assoc_opt name attrs with
+  match Attr_utils.get_attr name attrs with
   | None -> 1
   | Some v -> (
       try
···
 
 (** Parse the headers attribute into a list of IDs *)
 let parse_headers attrs =
-  match List.assoc_opt "headers" attrs with
+  match Attr_utils.get_attr "headers" attrs with
   | None -> []
   | Some v ->
       let parts = String.split_on_char ' ' v in
···
         table.state <- InCellInRowGroup;
         (* Record header ID if present *)
         if is_header then (
-          match List.assoc_opt "id" attrs with
+          match Attr_utils.get_attr "id" attrs with
           | Some id when String.length id > 0 -> Hashtbl.replace table.header_ids id ()
           | _ -> ());
         (* Parse cell attributes *)
···
         table.state <- InCellInImplicitRowGroup;
         (* Same logic as above *)
         if is_header then (
-          match List.assoc_opt "id" attrs with
+          match Attr_utils.get_attr "id" attrs with
           | Some id when String.length id > 0 -> Hashtbl.replace table.header_ids id ()
           | _ -> ());
         let colspan = abs (parse_positive_int attrs "colspan") in

lib/check/specialized/unknown_element_checker.ml

···
     state.stack <- name :: state.stack
 
   | Tag.Html tag ->
-    let name_lower = String.lowercase_ascii (Tag.tag_to_string (Tag.Html tag)) in
+    let name_lower = Astring.String.Ascii.lowercase (Tag.tag_to_string (Tag.Html tag)) in
     state.stack <- name_lower :: state.stack
 
   | _ -> ()  (* SVG, MathML, Custom elements are allowed *)

lib/check/specialized/url_checker.ml

···
 
 (** Check if pipe is allowed in this host context. *)
 let is_pipe_allowed_in_host url host =
-  let scheme = try String.lowercase_ascii (String.sub url 0 (String.index url ':')) with _ -> "" in
+  let scheme = try Astring.String.Ascii.lowercase (String.sub url 0 (String.index url ':')) with _ -> "" in
   scheme = "file" && is_valid_windows_drive host
 
 (** Special schemes that require double slash (//).
···
           (c >= '0' && c <= '9') || c = '+' || c = '-' || c = '.'
         ) potential_scheme in
       if is_valid_scheme then
-        Some (String.lowercase_ascii potential_scheme)
+        Some (Astring.String.Ascii.lowercase potential_scheme)
       else
         None
     with Not_found -> None
···
 let extract_host_and_port url =
   try
     let double_slash =
-      try Some (Str.search_forward (Str.regexp "://") url 0 + 3)
-      with Not_found -> None
+      match Astring.String.find_sub ~sub:"://" url with
+      | Some pos -> Some (pos + 3)
+      | None -> None
     in
     match double_slash with
     | None -> (None, None)
···
   (* Check for ASCII percent *)
   String.contains s '%' ||
   (* Check for fullwidth percent (U+FF05 = 0xEF 0xBC 0x85 in UTF-8) *)
-  try
-    let _ = Str.search_forward (Str.regexp "\xef\xbc\x85") s 0 in
-    true
-  with Not_found -> false
+  Astring.String.is_infix ~affix:"\xef\xbc\x85" s
 
 (** Check if decoded host contains forbidden characters.
     Some URLs have percent-encoded fullwidth characters that decode to forbidden chars. *)
···
 let check_path_segment url attr_name element_name =
   (* Extract path: everything after authority (or after scheme: for non-authority URLs) *)
   let raw_path =
-    try
-      let double_slash = Str.search_forward (Str.regexp "://") url 0 in
+    match Astring.String.find_sub ~sub:"://" url with
+    | Some double_slash ->
       let after_auth_start = double_slash + 3 in
       let rest = String.sub url after_auth_start (String.length url - after_auth_start) in
       (* Find end of authority *)
···
         String.sub rest path_start (String.length rest - path_start)
       else
         ""
-    with Not_found ->
+    | None ->
       (* No double slash - check for single slash path *)
-      match extract_scheme url with
+      (match extract_scheme url with
       | Some _ ->
-        let colon_pos = String.index url ':' in
-        let after_colon = String.sub url (colon_pos + 1) (String.length url - colon_pos - 1) in
-        after_colon
+        (try
+          let colon_pos = String.index url ':' in
+          String.sub url (colon_pos + 1) (String.length url - colon_pos - 1)
+        with Not_found -> url)
       | None ->
         (* Relative URL - the whole thing is the path *)
-        url
+        url)
   in
   (* Remove query and fragment for path-specific checks *)
   let path = remove_query_fragment raw_path in
···
 
 (** Check for illegal characters in userinfo (user:password). *)
 let check_userinfo url attr_name element_name =
+  match Astring.String.find_sub ~sub:"://" url with
+  | None -> None
+  | Some pos ->
   try
     (* Look for :// then find the LAST @ before the next / or end *)
-    let double_slash = Str.search_forward (Str.regexp "://") url 0 + 3 in
+    let double_slash = pos + 3 in
     let rest = String.sub url double_slash (String.length url - double_slash) in
     (* Find first / or ? or # to limit authority section *)
     let auth_end =
···
   let url = String.trim url in
   (* Empty URL check for certain attributes *)
   if url = "" then begin
-    let name_lower = String.lowercase_ascii element_name in
-    let attr_lower = String.lowercase_ascii attr_name in
+    let name_lower = Astring.String.Ascii.lowercase element_name in
+    let attr_lower = Astring.String.Ascii.lowercase attr_name in
     if List.mem attr_lower must_be_non_empty ||
        List.mem (name_lower, attr_lower) must_be_non_empty_combinations then
       Some (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad URL: Must be non-empty."
···
 let reset _state = ()
 
 (** Get attribute value by name. *)
-let get_attr_value name attrs =
-  List.find_map (fun (k, v) ->
-    if String.lowercase_ascii k = String.lowercase_ascii name then Some v else None
-  ) attrs
+let get_attr_value = Attr_utils.get_attr
 
 let start_element _state ~element collector =
   match element.Element.tag with
   | Tag.Html _ ->
     let name = Tag.tag_to_string element.tag in
-    let name_lower = String.lowercase_ascii name in
+    let name_lower = Astring.String.Ascii.lowercase name in
     let attrs = element.raw_attrs in
     (* Check URL attributes for elements that have them *)
     (match List.assoc_opt name_lower url_attributes with
···
               match validate_url url name "value" with
               | None -> ()
               | Some error_msg ->
-                let error_msg = Str.global_replace (Str.regexp "Bad URL:") "Bad absolute URL:" error_msg in
+                let error_msg = Astring.String.concat ~sep:"Bad absolute URL:" (Astring.String.cuts ~sep:"Bad URL:" error_msg) in
                 Message_collector.add_typed collector (`Attr (`Bad_value_generic (`Message error_msg)))
           end
       end

lib/check/specialized/xhtml_content_checker.ml

···
 
 let start_element state ~element collector =
   let name = Tag.tag_to_string element.Element.tag in
-  let name_lower = String.lowercase_ascii name in
+  let name_lower = Astring.String.Ascii.lowercase name in
   let attrs = element.raw_attrs in
 
   (* Check data-* attributes for uppercase *)
···
   (* Check if this element is allowed as child of parent *)
   (match state.element_stack with
   | parent :: _ ->
-      let parent_lower = String.lowercase_ascii parent in
+      let parent_lower = Astring.String.Ascii.lowercase parent in
       if not (is_child_allowed ~parent:parent_lower ~child:name_lower) then
         Message_collector.add_typed collector
           (`Element (`Not_allowed_as_child (`Child name_lower, `Parent parent_lower)))
···
 
   (* Handle figure content model *)
   (match state.element_stack with
-  | parent :: _ when String.lowercase_ascii parent = "figure" ->
+  | parent :: _ when Astring.String.Ascii.lowercase parent = "figure" ->
       (* We're inside a figure, check content model *)
       (match state.figure_stack with
       | fig :: _ ->
···
   state.element_stack <- name :: state.element_stack
 
 let end_element state ~tag _collector =
-  let name_lower = String.lowercase_ascii (Tag.tag_to_string tag) in
+  let name_lower = Astring.String.Ascii.lowercase (Tag.tag_to_string tag) in
   (* Pop figure state if leaving a figure *)
   if name_lower = "figure" then begin
     match state.figure_stack with
···
   match state.element_stack with
   | [] -> ()
   | parent :: _ ->
-      let parent_lower = String.lowercase_ascii parent in
+      let parent_lower = Astring.String.Ascii.lowercase parent in
       let trimmed = String.trim text in
       if trimmed <> "" then begin
         if parent_lower = "figure" then begin