perf

lib/htmlrw_check/context_tracker.ml

···
   (** Iterate over all contexts (top to bottom). *)
   val iter : 'a t -> ('a -> unit) -> unit
 end = struct
-  type 'a t = { mutable stack : 'a list }
+  type 'a t = { mutable stack : 'a list; mutable len : int }
 
-  let create () = { stack = [] }
-  let reset t = t.stack <- []
-  let push t x = t.stack <- x :: t.stack
+  let create () = { stack = []; len = 0 }
+  let reset t = t.stack <- []; t.len <- 0
+  let push t x = t.stack <- x :: t.stack; t.len <- t.len + 1
   let pop t = match t.stack with
     | [] -> None
-    | x :: rest -> t.stack <- rest; Some x
+    | x :: rest -> t.stack <- rest; t.len <- t.len - 1; Some x
   let current t = match t.stack with
     | [] -> None
     | x :: _ -> Some x
-  let depth t = List.length t.stack
-  let is_empty t = t.stack = []
+  let depth t = t.len  (* O(1) instead of O(n) *)
+  let is_empty t = t.len = 0
   let to_list t = List.rev t.stack
   let exists t f = List.exists f t.stack
   let find t f = List.find_opt f t.stack
···
   (** Get all ancestor names (outermost first). *)
   val to_list : t -> string list
 end = struct
-  type t = { mutable stack : string list }
+  type t = { mutable stack : string list; mutable len : int }
 
-  let create () = { stack = [] }
-  let reset t = t.stack <- []
-  let push t name = t.stack <- name :: t.stack
+  let create () = { stack = []; len = 0 }
+  let reset t = t.stack <- []; t.len <- 0
+  let push t name = t.stack <- name :: t.stack; t.len <- t.len + 1
   let pop t = match t.stack with
-    | _ :: rest -> t.stack <- rest
+    | _ :: rest -> t.stack <- rest; t.len <- t.len - 1
     | [] -> ()
   let parent t = match t.stack with
     | x :: _ -> Some x
     | [] -> None
   let has_ancestor t name = List.mem name t.stack
-  let depth t = List.length t.stack
+  let depth t = t.len  (* O(1) instead of O(n) *)
   let to_list t = List.rev t.stack
 end

lib/htmlrw_check/datatype/datatype.ml

···
   else String.sub s start (end_pos - start + 1)
 
 (** Factory for creating enum-based validators.
-    Many HTML attributes accept a fixed set of keyword values. *)
+    Many HTML attributes accept a fixed set of keyword values.
+    Uses Hashtbl for O(1) membership check. *)
 let make_enum ~name ~values ?(allow_empty = true) () : t =
-  let values_set = List.map String.lowercase_ascii values in
+  (* 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;
   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
-      if (allow_empty && s = "") || List.mem s_lower values_set then Ok ()
+      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)
     let is_valid s = Result.is_ok (validate s)

lib/htmlrw_check/element/tag.ml

···
 
 (** {1 Conversion Functions} *)
 
-(** Convert a lowercase tag name string to html_tag option *)
-let html_tag_of_string_opt name =
-  match name with
-  (* Document metadata *)
-  | "html" -> Some `Html | "head" -> Some `Head | "title" -> Some `Title
-  | "base" -> Some `Base | "link" -> Some `Link | "meta" -> Some `Meta
-  | "style" -> Some `Style
-  (* Sectioning root *)
-  | "body" -> Some `Body
-  (* Content sectioning *)
-  | "address" -> Some `Address | "article" -> Some `Article | "aside" -> Some `Aside
-  | "footer" -> Some `Footer | "header" -> Some `Header | "hgroup" -> Some `Hgroup
-  | "main" -> Some `Main | "nav" -> Some `Nav | "search" -> Some `Search
-  | "section" -> Some `Section
-  (* Headings *)
-  | "h1" -> Some `H1 | "h2" -> Some `H2 | "h3" -> Some `H3
-  | "h4" -> Some `H4 | "h5" -> Some `H5 | "h6" -> Some `H6
-  (* Grouping content *)
-  | "blockquote" -> Some `Blockquote | "dd" -> Some `Dd | "div" -> Some `Div
-  | "dl" -> Some `Dl | "dt" -> Some `Dt | "figcaption" -> Some `Figcaption
-  | "figure" -> Some `Figure | "hr" -> Some `Hr | "li" -> Some `Li
-  | "menu" -> Some `Menu | "ol" -> Some `Ol | "p" -> Some `P
-  | "pre" -> Some `Pre | "ul" -> Some `Ul
-  (* Text-level semantics *)
-  | "a" -> Some `A | "abbr" -> Some `Abbr | "b" -> Some `B
-  | "bdi" -> Some `Bdi | "bdo" -> Some `Bdo | "br" -> Some `Br
-  | "cite" -> Some `Cite | "code" -> Some `Code | "data" -> Some `Data
-  | "dfn" -> Some `Dfn | "em" -> Some `Em | "i" -> Some `I
-  | "kbd" -> Some `Kbd | "mark" -> Some `Mark | "q" -> Some `Q
-  | "rp" -> Some `Rp | "rt" -> Some `Rt | "ruby" -> Some `Ruby
-  | "s" -> Some `S | "samp" -> Some `Samp | "small" -> Some `Small
-  | "span" -> Some `Span | "strong" -> Some `Strong | "sub" -> Some `Sub
-  | "sup" -> Some `Sup | "time" -> Some `Time | "u" -> Some `U
-  | "var" -> Some `Var | "wbr" -> Some `Wbr
-  (* Edits *)
-  | "del" -> Some `Del | "ins" -> Some `Ins
-  (* Embedded content *)
-  | "area" -> Some `Area | "audio" -> Some `Audio | "canvas" -> Some `Canvas
-  | "embed" -> Some `Embed | "iframe" -> Some `Iframe | "img" -> Some `Img
-  | "map" -> Some `Map | "object" -> Some `Object | "picture" -> Some `Picture
-  | "source" -> Some `Source | "track" -> Some `Track | "video" -> Some `Video
-  (* Tabular data *)
-  | "caption" -> Some `Caption | "col" -> Some `Col | "colgroup" -> Some `Colgroup
-  | "table" -> Some `Table | "tbody" -> Some `Tbody | "td" -> Some `Td
-  | "tfoot" -> Some `Tfoot | "th" -> Some `Th | "thead" -> Some `Thead
-  | "tr" -> Some `Tr
-  (* Forms *)
-  | "button" -> Some `Button | "datalist" -> Some `Datalist
-  | "fieldset" -> Some `Fieldset | "form" -> Some `Form | "input" -> Some `Input
-  | "label" -> Some `Label | "legend" -> Some `Legend | "meter" -> Some `Meter
-  | "optgroup" -> Some `Optgroup | "option" -> Some `Option
-  | "output" -> Some `Output | "progress" -> Some `Progress
-  | "select" -> Some `Select | "textarea" -> Some `Textarea
-  (* Interactive *)
-  | "details" -> Some `Details | "dialog" -> Some `Dialog | "summary" -> Some `Summary
-  (* Scripting *)
-  | "noscript" -> Some `Noscript | "script" -> Some `Script
-  | "slot" -> Some `Slot | "template" -> Some `Template
-  (* Web Components / Misc *)
-  | "portal" -> Some `Portal | "param" -> Some `Param
-  (* Deprecated/obsolete elements *)
-  | "applet" -> Some `Applet | "acronym" -> Some `Acronym | "bgsound" -> Some `Bgsound
-  | "dir" -> Some `Dir | "frame" -> Some `Frame | "frameset" -> Some `Frameset
-  | "noframes" -> Some `Noframes | "isindex" -> Some `Isindex | "keygen" -> Some `Keygen
-  | "listing" -> Some `Listing | "menuitem" -> Some `Menuitem | "nextid" -> Some `Nextid
-  | "noembed" -> Some `Noembed | "plaintext" -> Some `Plaintext
-  | "rb" -> Some `Rb | "rtc" -> Some `Rtc | "strike" -> Some `Strike | "xmp" -> Some `Xmp
-  | "basefont" -> Some `Basefont | "big" -> Some `Big | "blink" -> Some `Blink
-  | "center" -> Some `Center | "font" -> Some `Font | "marquee" -> Some `Marquee
-  | "multicol" -> Some `Multicol | "nobr" -> Some `Nobr | "spacer" -> Some `Spacer
-  | "tt" -> Some `Tt | "image" -> Some `Image
-  | _ -> None
+(** Hashtable for O(1) tag name lookup - initialized once at module load *)
+let html_tag_table : (string, html_tag) Hashtbl.t =
+  let tbl = Hashtbl.create 128 in
+  List.iter (fun (name, tag) -> Hashtbl.add tbl name tag) [
+    (* Document metadata *)
+    ("html", `Html); ("head", `Head); ("title", `Title);
+    ("base", `Base); ("link", `Link); ("meta", `Meta); ("style", `Style);
+    (* Sectioning root *)
+    ("body", `Body);
+    (* Content sectioning *)
+    ("address", `Address); ("article", `Article); ("aside", `Aside);
+    ("footer", `Footer); ("header", `Header); ("hgroup", `Hgroup);
+    ("main", `Main); ("nav", `Nav); ("search", `Search); ("section", `Section);
+    (* Headings *)
+    ("h1", `H1); ("h2", `H2); ("h3", `H3);
+    ("h4", `H4); ("h5", `H5); ("h6", `H6);
+    (* Grouping content *)
+    ("blockquote", `Blockquote); ("dd", `Dd); ("div", `Div);
+    ("dl", `Dl); ("dt", `Dt); ("figcaption", `Figcaption);
+    ("figure", `Figure); ("hr", `Hr); ("li", `Li);
+    ("menu", `Menu); ("ol", `Ol); ("p", `P); ("pre", `Pre); ("ul", `Ul);
+    (* Text-level semantics *)
+    ("a", `A); ("abbr", `Abbr); ("b", `B);
+    ("bdi", `Bdi); ("bdo", `Bdo); ("br", `Br);
+    ("cite", `Cite); ("code", `Code); ("data", `Data);
+    ("dfn", `Dfn); ("em", `Em); ("i", `I);
+    ("kbd", `Kbd); ("mark", `Mark); ("q", `Q);
+    ("rp", `Rp); ("rt", `Rt); ("ruby", `Ruby);
+    ("s", `S); ("samp", `Samp); ("small", `Small);
+    ("span", `Span); ("strong", `Strong); ("sub", `Sub);
+    ("sup", `Sup); ("time", `Time); ("u", `U);
+    ("var", `Var); ("wbr", `Wbr);
+    (* Edits *)
+    ("del", `Del); ("ins", `Ins);
+    (* Embedded content *)
+    ("area", `Area); ("audio", `Audio); ("canvas", `Canvas);
+    ("embed", `Embed); ("iframe", `Iframe); ("img", `Img);
+    ("map", `Map); ("object", `Object); ("picture", `Picture);
+    ("source", `Source); ("track", `Track); ("video", `Video);
+    (* Tabular data *)
+    ("caption", `Caption); ("col", `Col); ("colgroup", `Colgroup);
+    ("table", `Table); ("tbody", `Tbody); ("td", `Td);
+    ("tfoot", `Tfoot); ("th", `Th); ("thead", `Thead); ("tr", `Tr);
+    (* Forms *)
+    ("button", `Button); ("datalist", `Datalist);
+    ("fieldset", `Fieldset); ("form", `Form); ("input", `Input);
+    ("label", `Label); ("legend", `Legend); ("meter", `Meter);
+    ("optgroup", `Optgroup); ("option", `Option);
+    ("output", `Output); ("progress", `Progress);
+    ("select", `Select); ("textarea", `Textarea);
+    (* Interactive *)
+    ("details", `Details); ("dialog", `Dialog); ("summary", `Summary);
+    (* Scripting *)
+    ("noscript", `Noscript); ("script", `Script);
+    ("slot", `Slot); ("template", `Template);
+    (* Web Components / Misc *)
+    ("portal", `Portal); ("param", `Param);
+    (* Deprecated/obsolete elements *)
+    ("applet", `Applet); ("acronym", `Acronym); ("bgsound", `Bgsound);
+    ("dir", `Dir); ("frame", `Frame); ("frameset", `Frameset);
+    ("noframes", `Noframes); ("isindex", `Isindex); ("keygen", `Keygen);
+    ("listing", `Listing); ("menuitem", `Menuitem); ("nextid", `Nextid);
+    ("noembed", `Noembed); ("plaintext", `Plaintext);
+    ("rb", `Rb); ("rtc", `Rtc); ("strike", `Strike); ("xmp", `Xmp);
+    ("basefont", `Basefont); ("big", `Big); ("blink", `Blink);
+    ("center", `Center); ("font", `Font); ("marquee", `Marquee);
+    ("multicol", `Multicol); ("nobr", `Nobr); ("spacer", `Spacer);
+    ("tt", `Tt); ("image", `Image);
+  ];
+  tbl
+
+(** Convert a lowercase tag name string to html_tag option - O(1) lookup *)
+let html_tag_of_string_opt name = Hashtbl.find_opt html_tag_table name
 
 (** Check if a name is a valid custom element name (contains hyphen, not reserved) *)
 let is_custom_element_name name =

lib/htmlrw_check/semantic/lang_detecting_checker.ml

···
 let max_chars = 30720
 let min_chars = 1024
 
-(* Elements whose text content we skip for language detection *)
-let skip_elements = [
-  "a"; "button"; "details"; "figcaption"; "form"; "li"; "nav";
-  "pre"; "script"; "select"; "span"; "style"; "summary";
-  "td"; "textarea"; "th"; "tr"
-]
+(* Elements whose text content we skip for language detection - O(1) lookup *)
+let skip_elements =
+  let tbl = Hashtbl.create 20 in
+  List.iter (fun e -> Hashtbl.add tbl e ()) [
+    "a"; "button"; "details"; "figcaption"; "form"; "li"; "nav";
+    "pre"; "script"; "select"; "span"; "style"; "summary";
+    "td"; "textarea"; "th"; "tr"
+  ];
+  tbl
 
-(* RTL languages *)
-let rtl_langs = ["ar"; "azb"; "ckb"; "dv"; "fa"; "he"; "pnb"; "ps"; "sd"; "ug"; "ur"; "iw"]
+let is_skip_element name = Hashtbl.mem skip_elements name
+
+(* RTL languages - O(1) lookup *)
+let rtl_langs =
+  let tbl = Hashtbl.create 16 in
+  List.iter (fun l -> Hashtbl.add tbl l ()) ["ar"; "azb"; "ckb"; "dv"; "fa"; "he"; "pnb"; "ps"; "sd"; "ug"; "ur"; "iw"];
+  tbl
+
+let is_rtl_lang lang = Hashtbl.mem rtl_langs lang
 
 let create () = {
   html_lang = None;
···
     if state.foreign_depth > 0 then
       state.foreign_depth <- state.foreign_depth + 1
     (* Check if we should skip this element's text *)
-    else if List.mem name_lower skip_elements then
+    else if is_skip_element name_lower then
       state.skip_depth <- state.skip_depth + 1
     else begin
       (* Check for different lang attribute *)
···
     if state.foreign_depth > 0 then
       state.foreign_depth <- state.foreign_depth - 1
     else if state.skip_depth > 0 then begin
-      if List.mem name_lower skip_elements then
+      if is_skip_element name_lower then
         state.skip_depth <- state.skip_depth - 1
       else
         (* TODO: properly track nested elements with different lang *)
···
         end;
 
         (* Check dir attribute for RTL languages *)
-        if List.mem base_detected rtl_langs then begin
+        if is_rtl_lang base_detected then begin
           match state.html_dir with
           | None ->
               Message_collector.add_typed collector

lib/htmlrw_check/semantic/nesting_checker.ml

···
      "s"; "small"; "mark"; "abbr"; "cite"; "code"; "q"; "sub"; "sup"; "samp";
      "kbd"; "var" |]
 
+(** Hashtable for O(1) lookup of special ancestor bit positions *)
+let special_ancestor_table : (string, int) Hashtbl.t =
+  let tbl = Hashtbl.create 64 in
+  Array.iteri (fun i name -> Hashtbl.add tbl name i) special_ancestors;
+  tbl
+
 (** Get the bit position for a special ancestor element.
-    Returns [-1] if the element is not a special ancestor. *)
+    Returns [-1] if the element is not a special ancestor. O(1) lookup. *)
 let special_ancestor_number name =
-  let rec find i =
-    if i >= Array.length special_ancestors then -1
-    else if special_ancestors.(i) = name then i
-    else find (i + 1)
-  in
-  find 0
+  match Hashtbl.find_opt special_ancestor_table name with
+  | Some i -> i
+  | None -> -1
 
 (** Interactive elements that cannot be nested inside [a] or [button]. *)
 let interactive_elements =

lib/htmlrw_check/semantic/obsolete_checker.ml

···
 
   tbl
 
-(** Obsolete style attributes map: attr_name -> element_name list *)
-let obsolete_style_attrs =
+(** Obsolete style attributes map: attr_name -> element_name -> unit hashtable
+    Uses nested hashtables for O(1) lookup instead of List.mem O(n) *)
+let obsolete_style_attrs : (string, (string, unit) Hashtbl.t) Hashtbl.t =
   let tbl = Hashtbl.create 64 in
 
   let register attr_name elements =
-    Hashtbl.add tbl attr_name elements
+    let elem_tbl = Hashtbl.create (List.length elements) in
+    List.iter (fun e -> Hashtbl.add elem_tbl e ()) elements;
+    Hashtbl.add tbl attr_name elem_tbl
   in
 
   register "align" ["caption"; "iframe"; "img"; "input"; "object"; "embed"; "legend"; "table"; "hr"; "div"; "h1"; "h2"; "h3"; "h4"; "h5"; "h6"; "p"; "col"; "colgroup"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"];
···
                 Message_collector.add_typed collector
                   (`Element (`Obsolete_attr (`Elem name, `Attr attr_name, `Suggestion (Some suggestion))))));
 
-        (* Check obsolete style attributes *)
+        (* Check obsolete style attributes - O(1) nested hashtable lookup *)
         (match Hashtbl.find_opt obsolete_style_attrs attr_lower with
         | None -> ()
-        | Some elements ->
-            if List.mem name_lower elements then
+        | Some elem_tbl ->
+            if Hashtbl.mem elem_tbl name_lower then
               Message_collector.add_typed collector
                 (`Element (`Obsolete_attr (`Elem name, `Attr attr_name, `Suggestion (Some "Use CSS instead.")))));
 

lib/htmlrw_check/specialized/label_checker.ml

···
     Validates that label element contains at most one labelable element
     and that descendants with for attribute have matching ids. *)
 
-(** Labelable elements that label can reference *)
-let labelable_elements = ["button"; "input"; "meter"; "output"; "progress"; "select"; "textarea"]
+(** Labelable elements that label can reference - O(1) hashtable lookup *)
+let labelable_elements =
+  let tbl = Hashtbl.create 8 in
+  List.iter (fun e -> Hashtbl.add tbl e ()) ["button"; "input"; "meter"; "output"; "progress"; "select"; "textarea"];
+  tbl
+
+let is_labelable name = Hashtbl.mem labelable_elements name
 
 type label_for_info = {
   for_target : string;
···
     let name_lower = String.lowercase_ascii (Tag.tag_to_string (Tag.Html tag)) in
 
     (* Track labelable element IDs *)
-    (if List.mem name_lower labelable_elements then
+    (if is_labelable name_lower then
       match Attr_utils.get_attr "id" element.raw_attrs with
       | Some id -> state.labelable_ids <- id :: state.labelable_ids
       | None -> ());
···
       state.label_depth <- state.label_depth + 1;
 
       (* Check for labelable elements inside label *)
-      if List.mem name_lower labelable_elements then begin
+      if is_labelable name_lower then begin
         state.labelable_count <- state.labelable_count + 1;
         if state.labelable_count > 1 then
           Message_collector.add_typed collector (`Label `Too_many_labelable);