refactor: Update italic correction handling for subscript nodes in layout engine

Author: erweixin

crates/ratex-layout/src/engine.rs

@@ -1213,10 +1213,22 @@ fn layout_supsub(
     // (KaTeX `margin-right: italic`), so we must not add `glyph_italic` again here.
     let italic_correction = 0.0;
 
-    // KaTeX `supsub.js`: for SymbolNode bases, subscripts get `margin-left: -base.italic` so they
-    // are not shifted by the base's italic correction (e.g. ∫_{A_1}).
+    // KaTeX `supsub.js`: only a direct `SymbolNode` base (plus the synthetic `\oiint` /
+    // `\oiiint` operators) gets `margin-left: -base.italic`.  In particular, spans such as
+    // `\text{\textit{CPI}}` and `{x}` must not inherit the italic correction of their last glyph.
     let sub_h_kern = if sub_box.is_some() && !center_scripts {
-        -glyph_italic(&base_box)
+        let direct_italic = direct_glyph_italic(&base_box);
+        let is_oiint = matches!(
+            base,
+            Some(ParseNode::Op {
+                name: Some(name),
+                ..
+            }) if name == "\\oiint" || name == "\\oiiint"
+        );
+        let base_italic = direct_italic
+            .or_else(|| is_oiint.then(|| first_glyph_italic(&base_box)).flatten())
+            .unwrap_or(0.0);
+        -base_italic
     } else {
         0.0
     };
@@ -1782,24 +1794,28 @@ fn layout_operatorname(body: &[ParseNode], options: &LayoutOptions) -> LayoutBox
 /// `\vec` KaTeX SVG: nudge slightly right to match KaTeX reference.
 const VEC_SKEW_EXTRA_RIGHT_EM: f64 = 0.018;
 
-/// Extract the italic correction of the base glyph.
-/// Used by superscripts: KaTeX adds margin-right = italic_correction to italic math characters,
-/// so the superscript starts at advance_width + italic_correction (not just advance_width).
-fn glyph_italic(lb: &LayoutBox) -> f64 {
-    let mut current = lb;
-    loop {
-        match &current.content {
-            BoxContent::Glyph { font_id, char_code } => {
-                return get_char_metrics(*font_id, *char_code)
-                    .map(|m| m.italic)
-                    .unwrap_or(0.0);
-            }
-            BoxContent::HBox(children) => match children.last() {
-                Some(last) => current = last,
-                None => return 0.0,
-            },
-            _ => return 0.0,
+/// Extract the italic correction only when this box itself is a glyph.
+///
+/// This distinction mirrors KaTeX's `base instanceof SymbolNode` check.  Recursing through an
+/// `HBox` would incorrectly treat text/group spans as symbols and pull their subscripts left.
+fn direct_glyph_italic(lb: &LayoutBox) -> Option<f64> {
+    match &lb.content {
+        BoxContent::Glyph { font_id, char_code } => {
+            get_char_metrics(*font_id, *char_code).map(|m| m.italic)
         }
+        _ => None,
+    }
+}
+
+/// Find the first glyph inside a box.
+///
+/// KaTeX special-cases `\oiint` and `\oiiint`: their overlay makes the base a span rather than a
+/// `SymbolNode`, but the underlying integral glyph's italic correction still applies.
+fn first_glyph_italic(lb: &LayoutBox) -> Option<f64> {
+    match &lb.content {
+        BoxContent::Glyph { .. } => direct_glyph_italic(lb),
+        BoxContent::HBox(children) => children.iter().find_map(first_glyph_italic),
+        _ => None,
     }
 }
 

crates/ratex-layout/tests/layout_vs_katex.rs

@@ -701,3 +701,48 @@ fn mathrm_mm_squared_both_m_upright() {
         "both m should be MainRegular, got {m_fonts:?}"
     );
 }
+
+#[test]
+fn subscript_italic_kern_only_applies_to_symbol_nodes() {
+    use ratex_layout::layout_box::{BoxContent, LayoutBox};
+
+    fn sub_h_kern(lb: &LayoutBox) -> Option<f64> {
+        match &lb.content {
+            BoxContent::SupSub { sub_h_kern, .. } => Some(*sub_h_kern),
+            BoxContent::HBox(children) => children.iter().find_map(sub_h_kern),
+            _ => None,
+        }
+    }
+
+    fn kern_for(expr: &str) -> f64 {
+        let ast = parse(expr).expect("parse");
+        let lbox = layout(&ast, &LayoutOptions::default());
+        sub_h_kern(&lbox).expect("supsub box")
+    }
+
+    assert!(
+        kern_for(r"f_i") < 0.0,
+        "a direct math symbol keeps its italic kern"
+    );
+    assert!(
+        kern_for(r"\mathit{f}_i") < 0.0,
+        "a single-glyph font node builds a direct symbol"
+    );
+    assert!(
+        kern_for(r"\oiint_i") < 0.0,
+        "KaTeX special-cases synthetic multi-integral operators"
+    );
+
+    for expr in [
+        r"{f}_i",
+        r"\mathit{ff}_i",
+        r"\text{\textit{CPI}}_t",
+        r"\color{red}{f}_i",
+    ] {
+        assert_eq!(
+            kern_for(expr),
+            0.0,
+            "span/group base must not inherit a nested glyph's italic correction: {expr}"
+        );
+    }
+}

tests/golden/fixtures/1051.png

@@ -1048,3 +1048,4 @@ a · b
 ⨆_{n} Q_n
 \textcolor{#ff000050}{x}
 ○\div□=5\quad□\div○=5
+{\text{\textit{Inflation}}} = 100 * \left({\text{\textit{CPI}}_{t} - \text{\textit{CPI}}_{t-1} \over \text{\textit{CPI}}_{t-1}}\right)