more

lib/html5_checker/semantic/lang_detecting_checker.ml

···
   mutable html_locator : (int * int) option;  (* line, column *)
   mutable in_body : bool;
   mutable skip_depth : int;  (* depth in elements to skip *)
+  mutable foreign_depth : int;  (* depth in SVG/MathML content to skip *)
   mutable text_buffer : Buffer.t;
   mutable char_count : int;
 }
···
   html_locator = None;
   in_body = false;
   skip_depth = 0;
+  foreign_depth = 0;
   text_buffer = Buffer.create 4096;
   char_count = 0;
 }
···
   state.html_locator <- None;
   state.in_body <- false;
   state.skip_depth <- 0;
+  state.foreign_depth <- 0;
   Buffer.clear state.text_buffer;
   state.char_count <- 0
 
+(* Namespaces to skip for language detection *)
+let svg_namespace = "http://www.w3.org/2000/svg"
+let mathml_namespace = "http://www.w3.org/1998/Math/MathML"
+
+let is_foreign_namespace ns =
+  ns = svg_namespace || ns = mathml_namespace
+
+(* Element names that start foreign content (for when namespace isn't set) *)
+let is_foreign_element name =
+  let n = String.lowercase_ascii name in
+  n = "svg" || n = "math"
+
 let get_attr name attrs =
   List.find_map (fun (n, v) ->
     if String.lowercase_ascii n = name then Some v else None
···
   | "zh-tw" -> "zh-hant"
   | _ -> code
 
-let start_element state ~name ~namespace:_ ~attrs _collector =
+let start_element state ~name ~namespace ~attrs _collector =
   let name_lower = String.lowercase_ascii name in
+  let ns = Option.value namespace ~default:"" in
 
   if name_lower = "html" then begin
     state.html_lang <- get_attr "lang" attrs;
···
   else if name_lower = "body" then
     state.in_body <- true
   else if state.in_body then begin
+    (* Track foreign namespace depth (SVG/MathML) *)
+    if is_foreign_namespace ns || is_foreign_element name then
+      state.foreign_depth <- state.foreign_depth + 1
+    else if state.foreign_depth > 0 then
+      state.foreign_depth <- state.foreign_depth + 1
     (* Check if we should skip this element's text *)
-    if List.mem name_lower skip_elements then
+    else if List.mem name_lower skip_elements then
       state.skip_depth <- state.skip_depth + 1
     else begin
       (* Check for different lang attribute *)
···
   let name_lower = String.lowercase_ascii name in
   if name_lower = "body" then
     state.in_body <- false
-  else if state.in_body && state.skip_depth > 0 then begin
-    if List.mem name_lower skip_elements then
-      state.skip_depth <- state.skip_depth - 1
-    else begin
-      (* TODO: properly track nested elements with different lang *)
-      state.skip_depth <- max 0 (state.skip_depth - 1)
+  else if state.in_body then begin
+    (* Track foreign namespace depth *)
+    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
+        state.skip_depth <- state.skip_depth - 1
+      else
+        (* TODO: properly track nested elements with different lang *)
+        state.skip_depth <- max 0 (state.skip_depth - 1)
     end
   end
 
 let characters state text _collector =
-  if state.in_body && state.skip_depth = 0 && state.char_count < max_chars then begin
+  if state.in_body && state.skip_depth = 0 && state.foreign_depth = 0 && state.char_count < max_chars then begin
     (* Count Unicode code points, not bytes *)
     let decoder = Uutf.decoder ~encoding:`UTF_8 (`String text) in
     let rec process () =
···
     match Langdetect.detect_with_prob detector text with
     | None -> ()
     | Some (detected_lang, prob) when prob > 0.90 ->
-        let declared_lang = match state.html_lang with
-          | Some l -> get_lang_code l
+        (* Get the original declared lang value (preserve exactly as written) *)
+        let original_declared = match state.html_lang with
+          | Some l -> l
           | None -> ""
         in
         let detected_code = detected_lang in  (* Keep full code like zh-tw *)
         let detected_name = get_language_name detected_lang in
         let suggested_code = get_bcp47_code detected_lang in
 
-        (* Check for language mismatch *)
-        let base_declared = get_lang_code declared_lang in
+        (* Check for language mismatch using base codes *)
+        let base_declared = get_lang_code original_declared in
         let base_detected = get_lang_code detected_code in
-        if declared_lang = "" then begin
+        if original_declared = "" then begin
           (* No lang attribute - suggest adding one *)
           Message_collector.add_warning collector
             ~message:(Printf.sprintf
···
           Message_collector.add_warning collector
             ~message:(Printf.sprintf
               "This document appears to be written in %s but the \xe2\x80\x9chtml\xe2\x80\x9d start tag has \xe2\x80\x9clang=\"%s\"\xe2\x80\x9d. Consider using \xe2\x80\x9clang=\"%s\"\xe2\x80\x9d (or variant) instead."
-              detected_name declared_lang suggested_code)
+              detected_name original_declared suggested_code)
             ~code:"wrong-lang"
             ~element:"html"
             ()

lib/html5_checker/specialized/h1_checker.ml

···
 
 type state = {
   mutable h1_count : int;
+  mutable svg_depth : int;  (* Track depth inside SVG *)
 }
 
 let create () = {
   h1_count = 0;
+  svg_depth = 0;
 }
 
 let reset state =
-  state.h1_count <- 0
+  state.h1_count <- 0;
+  state.svg_depth <- 0
 
 let start_element state ~name ~namespace ~attrs collector =
   ignore attrs;
-  if namespace <> None then ()
-  else begin
-    let name_lower = String.lowercase_ascii name in
-    if name_lower = "h1" then begin
-      state.h1_count <- state.h1_count + 1;
-      if state.h1_count > 1 then
-        Message_collector.add_info collector
-          ~message:"Consider using only one \xe2\x80\x9ch1\xe2\x80\x9d element per document (or, if using \xe2\x80\x9ch1\xe2\x80\x9d elements multiple times is required, consider using the \xe2\x80\x9cheadingoffset\xe2\x80\x9d attribute to indicate that these \xe2\x80\x9ch1\xe2\x80\x9d elements are not all top-level headings)."
-          ~code:"multiple-h1"
-          ~element:name ()
-    end
+  let name_lower = String.lowercase_ascii name in
+  (* Track SVG depth - h1 inside SVG (foreignObject, desc) shouldn't count *)
+  if name_lower = "svg" then
+    state.svg_depth <- state.svg_depth + 1
+  else if namespace <> None || state.svg_depth > 0 then
+    ()  (* Skip non-HTML namespace or inside SVG *)
+  else if name_lower = "h1" then begin
+    state.h1_count <- state.h1_count + 1;
+    if state.h1_count > 1 then
+      Message_collector.add_info collector
+        ~message:"Consider using only one \xe2\x80\x9ch1\xe2\x80\x9d element per document (or, if using \xe2\x80\x9ch1\xe2\x80\x9d elements multiple times is required, consider using the \xe2\x80\x9cheadingoffset\xe2\x80\x9d attribute to indicate that these \xe2\x80\x9ch1\xe2\x80\x9d elements are not all top-level headings)."
+        ~code:"multiple-h1"
+        ~element:name ()
   end
 
-let end_element _state ~name:_ ~namespace:_ _collector = ()
+let end_element state ~name ~namespace:_ _collector =
+  let name_lower = String.lowercase_ascii name in
+  if name_lower = "svg" && state.svg_depth > 0 then
+    state.svg_depth <- state.svg_depth - 1
+
 let characters _state _text _collector = ()
 let end_document _state _collector = ()