fix javascript overflow

lib/check/semantic/nesting_checker.ml

···
-(** Interactive element nesting checker implementation. *)
+(** Interactive element nesting checker implementation.
 
-(** Special ancestors that need tracking for nesting validation.
+    Uses bool arrays instead of bitmasks for JavaScript compatibility
+    (JS bitwise ops are limited to 32 bits). *)
 
-    This array defines the elements whose presence in the ancestor chain
-    affects validation of descendant elements. The order is significant
-    as it determines bit positions in the ancestor bitmask. *)
+(** Special ancestors that need tracking for nesting validation. *)
 let special_ancestors =
   [| "a"; "address"; "body"; "button"; "caption"; "dfn"; "dt"; "figcaption";
      "figure"; "footer"; "form"; "header"; "label"; "map"; "noscript"; "th";
···
      "s"; "small"; "mark"; "abbr"; "cite"; "code"; "q"; "sub"; "sup"; "samp";
      "kbd"; "var" |]
 
-(** Hashtable for O(1) lookup of special ancestor bit positions *)
+let num_ancestors = Array.length special_ancestors
+
+(** Hashtable for O(1) lookup of special ancestor indices *)
 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. O(1) lookup. *)
-let special_ancestor_number name =
+(** Get the index for a special ancestor element.
+    Returns [-1] if the element is not a special ancestor. *)
+let special_ancestor_index name =
   match Hashtbl.find_opt special_ancestor_table name with
   | Some i -> i
   | None -> -1
···
   [| "a"; "button"; "details"; "embed"; "iframe"; "label"; "select";
      "textarea" |]
 
-(** Map from descendant element name to bitmask of prohibited ancestors. *)
-let ancestor_mask_by_descendant : (string, int) Hashtbl.t =
+(** Create an empty bool array for ancestor tracking *)
+let empty_flags () = Array.make num_ancestors false
+
+(** Copy a bool array *)
+let copy_flags flags = Array.copy flags
+
+(** Map from descendant element name to prohibited ancestor flags. *)
+let prohibited_ancestors_by_descendant : (string, bool array) Hashtbl.t =
   Hashtbl.create 64
 
-(** Map from descendant element name to bitmask of ancestors that cause content model violations.
-    (These use different error messages than nesting violations.) *)
-let content_model_violation_mask : (string, int) Hashtbl.t =
+(** Map from descendant element name to content model violation flags. *)
+let content_model_violations : (string, bool array) Hashtbl.t =
   Hashtbl.create 64
 
+(** Get or create prohibited ancestors array for a descendant *)
+let get_prohibited descendant =
+  match Hashtbl.find_opt prohibited_ancestors_by_descendant descendant with
+  | Some arr -> arr
+  | None ->
+      let arr = empty_flags () in
+      Hashtbl.replace prohibited_ancestors_by_descendant descendant arr;
+      arr
+
+(** Get or create content model violations array for a descendant *)
+let get_content_model_violations descendant =
+  match Hashtbl.find_opt content_model_violations descendant with
+  | Some arr -> arr
+  | None ->
+      let arr = empty_flags () in
+      Hashtbl.replace content_model_violations descendant arr;
+      arr
+
 (** Register that [ancestor] is prohibited for [descendant]. *)
 let register_prohibited_ancestor ancestor descendant =
-  let number = special_ancestor_number ancestor in
-  if number = -1 then
+  let idx = special_ancestor_index ancestor in
+  if idx = -1 then
     failwith ("Ancestor not found in array: " ^ ancestor);
-  let mask =
-    match Hashtbl.find_opt ancestor_mask_by_descendant descendant with
-    | None -> 0
-    | Some m -> m
-  in
-  let new_mask = mask lor (1 lsl number) in
-  Hashtbl.replace ancestor_mask_by_descendant descendant new_mask
+  let arr = get_prohibited descendant in
+  arr.(idx) <- true
 
 (** Register a content model violation (phrasing-only element containing flow content). *)
 let register_content_model_violation ancestor descendant =
   register_prohibited_ancestor ancestor descendant;
-  let number = special_ancestor_number ancestor in
-  let mask =
-    match Hashtbl.find_opt content_model_violation_mask descendant with
-    | None -> 0
-    | Some m -> m
-  in
-  let new_mask = mask lor (1 lsl number) in
-  Hashtbl.replace content_model_violation_mask descendant new_mask
+  let idx = special_ancestor_index ancestor in
+  let arr = get_content_model_violations descendant in
+  arr.(idx) <- true
 
 (** Initialize the prohibited ancestor map. *)
 let () =
···
   ) interactive_elements;
 
   (* Phrasing-only elements: cannot contain flow content like p, div, h1-h6, etc. *)
-  (* These are content model violations, not nesting violations. *)
   let phrasing_only = ["span"; "strong"; "em"; "b"; "i"; "u"; "s"; "small"; "mark";
                         "abbr"; "cite"; "code"; "q"; "sub"; "sup"; "samp"; "kbd"; "var"] in
   let flow_content = ["p"; "div"; "article"; "section"; "nav"; "aside"; "header"; "footer";
···
     ) flow_content
   ) phrasing_only
 
-(** Bitmask constants for common checks. *)
-let a_button_mask =
-  let a_num = special_ancestor_number "a" in
-  let button_num = special_ancestor_number "button" in
-  (1 lsl a_num) lor (1 lsl button_num)
-
-let map_mask =
-  let map_num = special_ancestor_number "map" in
-  1 lsl map_num
+(** Indices for common checks *)
+let a_index = special_ancestor_index "a"
+let button_index = special_ancestor_index "button"
+let map_index = special_ancestor_index "map"
 
-(** Transparent elements - inherit content model from parent. O(1) hashtable lookup. *)
+(** Transparent elements - inherit content model from parent. *)
 let transparent_elements_tbl =
   Attr_utils.hashtbl_of_list ["a"; "canvas"; "video"; "audio"; "object"; "ins"; "del"; "map"]
 
···
 
 (** Stack node representing an element's context. *)
 type stack_node = {
-  ancestor_mask : int;
+  ancestor_flags : bool array;
   name : string;
   is_transparent : bool;
 }
···
 (** Checker state. *)
 type state = {
   mutable stack : stack_node list;
-  mutable ancestor_mask : int;
+  mutable ancestor_flags : bool array;
 }
 
 let create () =
-  { stack = []; ancestor_mask = 0 }
+  { stack = []; ancestor_flags = empty_flags () }
 
 let reset state =
   state.stack <- [];
-  state.ancestor_mask <- 0
+  state.ancestor_flags <- empty_flags ()
 
 (** Get attribute value by name from attribute list. *)
 let get_attr attrs name =
···
 (** 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 attrs "href"
+  | "audio" | "video" -> has_attr attrs "controls"
+  | "img" | "object" -> has_attr attrs "usemap"
   | "input" ->
-      begin match get_attr attrs "type" with
-      | Some "hidden" -> false
-      | _ -> true
-      end
+      (match get_attr attrs "type" with
+       | Some "hidden" -> false
+       | _ -> true)
   | "button" | "details" | "embed" | "iframe" | "label" | "select"
-  | "textarea" ->
-      true
-  | _ ->
-      false
+  | "textarea" -> true
+  | _ -> false
 
-(** Find the nearest transparent element in the ancestor stack, if any.
-    Returns the immediate parent's name if it's transparent, otherwise None. *)
+(** Find the nearest transparent element in the ancestor stack. *)
 let find_nearest_transparent_parent state =
   match state.stack with
   | parent :: _ when parent.is_transparent -> Some parent.name
···
 
 (** Report nesting violations. *)
 let check_nesting state name attrs collector =
-  (* Compute the prohibited ancestor mask for this element *)
-  let base_mask =
-    match Hashtbl.find_opt ancestor_mask_by_descendant name with
-    | Some m -> m
-    | None -> 0
+  (* Get prohibited ancestors for this element *)
+  let prohibited =
+    match Hashtbl.find_opt prohibited_ancestors_by_descendant name with
+    | Some arr -> arr
+    | None -> empty_flags ()
   in
 
-  (* Get content model violation mask for this element *)
-  let content_model_mask =
-    match Hashtbl.find_opt content_model_violation_mask name with
-    | Some m -> m
-    | None -> 0
+  (* Get content model violations for this element *)
+  let content_violations =
+    match Hashtbl.find_opt content_model_violations name with
+    | Some arr -> arr
+    | None -> empty_flags ()
   in
 
-  (* Add interactive element restrictions if applicable *)
-  let mask =
-    if is_interactive_element name attrs then
-      base_mask lor a_button_mask
-    else
-      base_mask
+  (* Check if element is interactive (adds a/button restrictions) *)
+  let is_interactive = is_interactive_element name attrs in
+
+  (* 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"
+    | _ -> None
   in
 
-  (* Check for violations *)
-  if mask <> 0 then begin
-    let mask_hit = state.ancestor_mask land mask in
-    if mask_hit <> 0 then begin
-      (* Determine if element has a special attribute to mention *)
-      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"
-        | _ -> None
+  (* Find transparent parent if any *)
+  let transparent_parent = find_nearest_transparent_parent state in
+
+  (* Check each special ancestor *)
+  Array.iteri (fun i ancestor ->
+    (* Is this ancestor in our current ancestor chain? *)
+    if state.ancestor_flags.(i) then begin
+      (* Is this ancestor prohibited for this element? *)
+      let is_prohibited =
+        prohibited.(i) ||
+        (is_interactive && (i = a_index || i = button_index))
       in
-      (* Find the transparent parent (like canvas) if any *)
-      let transparent_parent = find_nearest_transparent_parent state in
-      (* Find which ancestors are violated *)
-      Array.iteri (fun i ancestor ->
-        let bit = 1 lsl i in
-        if (mask_hit land bit) <> 0 then begin
-          (* Check if this is a content model violation or a nesting violation *)
-          if (content_model_mask land bit) <> 0 then begin
-            (* Content model violation: use "not allowed as child" format *)
-            (* If there's a transparent parent, use that instead of the ancestor *)
-            let parent = match transparent_parent with
-              | Some p -> p
-              | None -> ancestor
-            in
-            Message_collector.add_typed collector
-              (`Element (`Not_allowed_as_child (`Child name, `Parent parent)))
-          end else
-            (* Nesting violation: use "must not be descendant" format *)
-            Message_collector.add_typed collector
-              (`Element (`Must_not_descend (`Elem name, `Attr attr, `Ancestor ancestor)))
-        end
-      ) special_ancestors
+      if is_prohibited then begin
+        (* Is this a content model violation or a nesting violation? *)
+        if content_violations.(i) then begin
+          (* Content model violation: use "not allowed as child" format *)
+          let parent = match transparent_parent with
+            | Some p -> p
+            | None -> ancestor
+          in
+          Message_collector.add_typed collector
+            (`Element (`Not_allowed_as_child (`Child name, `Parent parent)))
+        end else
+          (* Nesting violation: use "must not be descendant" format *)
+          Message_collector.add_typed collector
+            (`Element (`Must_not_descend (`Elem name, `Attr attr, `Ancestor ancestor)))
+      end
     end
-  end
+  ) special_ancestors
 
 (** Check for required ancestors. *)
 let check_required_ancestors state name collector =
   match name with
   | "area" ->
-      if (state.ancestor_mask land map_mask) = 0 then
+      if not state.ancestor_flags.(map_index) then
         Message_collector.add_typed collector
           (`Generic (Printf.sprintf "The %s element must have a %s ancestor."
               (Error_code.q "area") (Error_code.q "map")))
   | _ -> ()
 
-(** Check for metadata-only elements appearing outside valid contexts.
-    style element is only valid in head or in noscript (in head). *)
+(** Check for metadata-only elements appearing outside valid contexts. *)
 let check_metadata_element_context state name collector =
   match name with
   | "style" ->
-      (* style is only valid inside head or noscript *)
-      begin match state.stack with
-      | parent :: _ when parent.name = "head" -> ()  (* valid *)
-      | parent :: _ when parent.name = "noscript" -> ()  (* valid in noscript in head *)
-      | parent :: _ ->
-          (* style inside any other element is not allowed *)
-          Message_collector.add_typed collector
-            (`Element (`Not_allowed_as_child (`Child "style", `Parent parent.name)))
-      | [] -> ()  (* at root level, would be caught elsewhere *)
-      end
+      (match state.stack with
+       | parent :: _ when parent.name = "head" -> ()
+       | parent :: _ when parent.name = "noscript" -> ()
+       | parent :: _ ->
+           Message_collector.add_typed collector
+             (`Element (`Not_allowed_as_child (`Child "style", `Parent parent.name)))
+       | [] -> ())
   | _ -> ()
 
 let start_element state ~element collector =
-  (* Only check HTML elements, not SVG or MathML *)
   match element.Element.tag with
   | Tag.Html _ ->
       let name = Tag.tag_to_string element.tag in
       let attrs = element.raw_attrs in
+
       (* Check for nesting violations *)
       check_nesting state name attrs collector;
       check_required_ancestors state name collector;
       check_metadata_element_context state name collector;
 
-      (* Update ancestor mask if this is a special ancestor *)
-      let new_mask = state.ancestor_mask in
-      let number = special_ancestor_number name in
-      let new_mask =
-        if number >= 0 then
-          new_mask lor (1 lsl number)
-        else
-          new_mask
-      in
+      (* Create new flags, copying current state *)
+      let new_flags = copy_flags state.ancestor_flags in
 
-      (* Add href tracking for <a> elements *)
-      let new_mask =
-        if name = "a" && has_attr attrs "href" then
-          let a_num = special_ancestor_number "a" in
-          new_mask lor (1 lsl a_num)
-        else
-          new_mask
-      in
+      (* Set flag if this is a special ancestor *)
+      let idx = special_ancestor_index name in
+      if idx >= 0 then
+        new_flags.(idx) <- true;
 
-      (* Push onto stack *)
+      (* Push onto stack (save old flags) *)
       let is_transparent = is_transparent_element name in
-      let node = { ancestor_mask = state.ancestor_mask; name; is_transparent } in
+      let node = { ancestor_flags = state.ancestor_flags; name; is_transparent } in
       state.stack <- node :: state.stack;
-      state.ancestor_mask <- new_mask
-  | _ -> ()  (* SVG, MathML, Custom, Unknown *)
+      state.ancestor_flags <- new_flags
+  | _ -> ()
 
 let end_element state ~tag _collector =
-  (* Only track HTML elements *)
   match tag with
   | Tag.Html _ ->
-      (* Pop from stack and restore ancestor mask *)
-      begin match state.stack with
-      | [] -> ()  (* Should not happen in well-formed documents *)
-      | node :: rest ->
-          state.stack <- rest;
-          state.ancestor_mask <- node.ancestor_mask
-      end
+      (match state.stack with
+       | [] -> ()
+       | node :: rest ->
+           state.stack <- rest;
+           state.ancestor_flags <- node.ancestor_flags)
   | _ -> ()
 
-(** Create the checker as a first-class module. *)
 let checker = Checker.make ~create ~reset ~start_element ~end_element ()