Merge pull request #5 from erweixin/fix-above

Fix above
nsupseteqq

Author: erweixin

crates/ratex-font/src/data/symbols_data.rs

@@ -1875,15 +1875,15 @@ pub static SYMBOLS: &[SymbolEntry] = &[
     ("\\@nshortmid", 0, 1, "rel", Some('\u{E006}')),
     ("\\@nshortparallel", 0, 1, "rel", Some('\u{E007}')),
     ("\\@nsubseteqq", 0, 1, "rel", Some('\u{E016}')),
-    ("\\@nsupseteqq", 0, 1, "rel", Some('\u{E017}')),
-    ("\\@varsubsetneq", 0, 1, "rel", Some('\u{E018}')),
-    ("\\@varsubsetneqq", 0, 1, "rel", Some('\u{E019}')),
-    ("\\@varsupsetneq", 0, 1, "rel", Some('\u{E01A}')),
-    ("\\@varsupsetneqq", 0, 1, "rel", Some('\u{E01B}')),
+    ("\\@nsupseteqq", 0, 1, "rel", Some('\u{E018}')),
+    ("\\@varsubsetneq", 0, 1, "rel", Some('\u{E01A}')),
+    ("\\@varsubsetneqq", 0, 1, "rel", Some('\u{E017}')),
+    ("\\@varsupsetneq", 0, 1, "rel", Some('\u{E01B}')),
+    ("\\@varsupsetneqq", 0, 1, "rel", Some('\u{E019}')),
     ("\\@imath", 0, 0, "mathord", Some('\u{E131}')),
     ("\\@jmath", 0, 0, "mathord", Some('\u{E237}')),
-    ("\\@ulcorner", 0, 1, "open", Some('\u{E01C}')),
-    ("\\@urcorner", 0, 1, "close", Some('\u{E01D}')),
-    ("\\@llcorner", 0, 1, "open", Some('\u{E01E}')),
-    ("\\@lrcorner", 0, 1, "close", Some('\u{E01F}')),
+    ("\\@ulcorner", 0, 1, "open", Some('\u{250C}')),
+    ("\\@urcorner", 0, 1, "close", Some('\u{2510}')),
+    ("\\@llcorner", 0, 1, "open", Some('\u{2514}')),
+    ("\\@lrcorner", 0, 1, "close", Some('\u{2518}')),
 ];

crates/ratex-layout/src/engine.rs

@@ -198,7 +198,7 @@ fn layout_node(node: &ParseNode, options: &LayoutOptions) -> LayoutBox {
             let bar_thickness = if *has_bar_line {
                 bar_size
                     .as_ref()
-                    .map(|m| m.number * options.metrics().default_rule_thickness)
+                    .map(|m| measurement_to_em(m, options))
                     .unwrap_or(options.metrics().default_rule_thickness)
             } else {
                 0.0
@@ -1427,7 +1427,12 @@ fn layout_accent(
         0.0
     };
 
-    let gap = if use_arrow_path { 0.12 } else { 0.0 };
+    // gap = clearance between body top and bottom of accent SVG.
+    // For arrow accents, the SVG path is centered (height=h/2, depth=h/2).
+    // The gap prevents the visible arrowhead boundary from overlapping with body top.
+    let gap = if use_arrow_path {
+        if label == "\\Overrightarrow" { 0.21 } else { 0.12 }
+    } else { 0.0 };
 
     let clearance = if is_below {
         body_box.height + body_box.depth + accent_box.depth + gap
@@ -2423,12 +2428,16 @@ fn layout_overline(body: &ParseNode, options: &LayoutOptions) -> LayoutBox {
     let metrics = options.metrics();
     let rule = metrics.default_rule_thickness;
 
+    // Total height: body height + 2*rule clearance + rule thickness = body.height + 3*rule
     let height = body_box.height + 3.0 * rule;
     LayoutBox {
         width: body_box.width,
         height,
         depth: body_box.depth,
-        content: BoxContent::HBox(vec![body_box]),
+        content: BoxContent::Overline {
+            body: Box::new(body_box),
+            rule_thickness: rule,
+        },
         color: options.color,
     }
 }
@@ -2438,12 +2447,16 @@ fn layout_underline(body: &ParseNode, options: &LayoutOptions) -> LayoutBox {
     let metrics = options.metrics();
     let rule = metrics.default_rule_thickness;
 
+    // Total depth: body depth + 2*rule clearance + rule thickness = body.depth + 3*rule
     let depth = body_box.depth + 3.0 * rule;
     LayoutBox {
         width: body_box.width,
         height: body_box.height,
         depth,
-        content: BoxContent::HBox(vec![body_box]),
+        content: BoxContent::Underline {
+            body: Box::new(body_box),
+            rule_thickness: rule,
+        },
         color: options.color,
     }
 }
@@ -2463,7 +2476,13 @@ fn layout_spacing_command(text: &str, options: &LayoutOptions) -> LayoutBox {
         "\\!" | "\\negthinspace" => -3.0 * mu,
         "\\negmedspace" => -4.0 * mu,
         "\\negthickspace" => -5.0 * mu,
-        "~" | "\\nobreakspace" | "\\ " => metrics.space,
+        "~" | "\\nobreakspace" | "\\ " | "\\space" => {
+            // KaTeX renders these by placing the U+00A0 glyph (char 160) via mathsym.
+            // Look up its width from MainRegular; fall back to 0.25em (the font-defined value).
+            get_char_metrics(FontId::MainRegular, 160)
+                .map(|m| m.width)
+                .unwrap_or(0.25)
+        }
         "\\quad" => metrics.quad,
         "\\qquad" => 2.0 * metrics.quad,
         "\\enspace" => metrics.quad / 2.0,
@@ -2687,37 +2706,50 @@ fn layout_xarrow(
         color: options.color,
     };
 
+    // KaTeX positions xarrows centered on the math axis, with a 0.111em (2mu) gap
+    // between the arrow and the text above/below (see amsmath.dtx reference).
     let metrics = options.metrics();
-    let _sp1 = 0.111; // bigOpSpacing1 — above the superscript
-    let _sp2 = 0.166; // bigOpSpacing2 — below the subscript
-    let sp3 = 0.2;   // bigOpSpacing3 — gap between base and script
-    let sp5 = metrics.big_op_spacing5;
+    let axis = metrics.axis_height;        // 0.25em
+    let arrow_half = actual_arrow_h / 2.0;
+    let gap = 0.111;                       // 2mu gap (KaTeX constant)
+
+    // Center the arrow on the math axis by shifting it up.
+    let base_shift = -axis;
+
+    // sup_kern: gap between arrow top and text bottom.
+    // In the OpLimits renderer:
+    //   sup_y = y - (arrow_half - base_shift) - sup_kern - sup_box.depth * ratio
+    //         = y - (arrow_half + axis) - sup_kern - sup_box.depth * ratio
+    // KaTeX: text_baseline = -(axis + arrow_half + gap)
+    //   (with extra -= depth when depth > 0.25, but that's rare for typical text)
+    // Matching: sup_kern = gap
+    let sup_kern = gap;
+    let sub_kern = gap;
 
-    let total_w = arrow_w;
     let sup_h = body_box.height * sup_ratio;
     let sup_d = body_box.depth * sup_ratio;
 
-    let height = arrow_box.height + sp3 + sup_h + sup_d + sp5;
-    let mut depth = arrow_box.depth + sp5;
+    // Height: from baseline to top of upper text
+    let height = axis + arrow_half + gap + sup_h + sup_d;
+    // Depth: arrow bottom below baseline = arrow_half - axis
+    let mut depth = (arrow_half - axis).max(0.0);
 
     if let Some(ref bel) = below_box {
         let sub_h = bel.height * sub_ratio;
         let sub_d = bel.depth * sub_ratio;
-        depth = arrow_box.depth + sp3 + sub_h + sub_d + sp5;
+        // Lower text positioned symmetrically below the arrow
+        depth = (arrow_half - axis) + gap + sub_h + sub_d;
     }
 
-    let sup_kern = sp3;
-    let sub_kern = sp3;
-
     LayoutBox {
-        width: total_w,
+        width: arrow_w,
         height,
         depth,
         content: BoxContent::OpLimits {
             base: Box::new(arrow_box),
             sup: Some(Box::new(body_box)),
             sub: below_box.map(Box::new),
-            base_shift: 0.0,
+            base_shift,
             sup_kern,
             sub_kern,
             slant: 0.0,

crates/ratex-layout/src/layout_box.rs

@@ -149,6 +149,20 @@ pub enum BoxContent {
         body: Box<LayoutBox>,
     },
 
+    /// \overline{body}: body with a horizontal rule drawn above it.
+    /// The rule sits `2 * rule_thickness` above the body's top (clearance), and is `rule_thickness` thick.
+    Overline {
+        body: Box<LayoutBox>,
+        rule_thickness: f64,
+    },
+
+    /// \underline{body}: body with a horizontal rule drawn below it.
+    /// The rule sits `2 * rule_thickness` below the body's bottom (clearance), and is `rule_thickness` thick.
+    Underline {
+        body: Box<LayoutBox>,
+        rule_thickness: f64,
+    },
+
     /// Empty placeholder.
     Empty,
 }

crates/ratex-layout/src/to_display.rs

@@ -419,6 +419,32 @@ fn emit_box(lbox: &LayoutBox, x: f64, y: f64, scale: f64, items: &mut Vec<Displa
             emit_box(body, x, y, scale, items);
         }
 
+        BoxContent::Overline { body, rule_thickness } => {
+            emit_box(body, x, y, scale, items);
+            // Rule center is at 2.5 * rule_thickness above the body's top
+            let rule_center_y = y - (body.height + 2.5 * rule_thickness) * scale;
+            items.push(DisplayItem::Line {
+                x,
+                y: rule_center_y,
+                width: lbox.width * scale,
+                thickness: rule_thickness * scale,
+                color: lbox.color,
+            });
+        }
+
+        BoxContent::Underline { body, rule_thickness } => {
+            emit_box(body, x, y, scale, items);
+            // Rule center is at 2.5 * rule_thickness below the body's bottom
+            let rule_center_y = y + (body.depth + 2.5 * rule_thickness) * scale;
+            items.push(DisplayItem::Line {
+                x,
+                y: rule_center_y,
+                width: lbox.width * scale,
+                thickness: rule_thickness * scale,
+                color: lbox.color,
+            });
+        }
+
         BoxContent::Kern | BoxContent::Empty => {}
     }
 }

crates/ratex-parser/src/macro_expander.rs

@@ -348,7 +348,7 @@ impl<'a> MacroExpander<'a> {
             ("\\bra", "\\mathinner{\\langle{#1}|}"),
             ("\\ket", "\\mathinner{|{#1}\\rangle}"),
             ("\\braket", "\\mathinner{\\langle{#1}\\rangle}"),
-            ("\\Braket", "\\mathinner{\\langle{#1}\\rangle}"),
+            ("\\Braket", "\\bra@ket{\\left\\langle}{\\;\\middle\\vert\\;}{\\;\\middle\\Vert\\;}{\\right\\rangle}"),
             ("\\Bra", "\\left\\langle#1\\right|"),
             ("\\Ket", "\\left|#1\\right\\rangle"),
 
@@ -676,6 +676,69 @@ impl<'a> MacroExpander<'a> {
             );
         }
 
+        // \bra@ket: like \bra@set but replaces ALL | at depth 0 (for \Braket)
+        self.macros.set(
+            "\\bra@ket".to_string(),
+            MacroDefinition::Function(|me: &mut MacroExpander| -> ParseResult<Vec<Token>> {
+                let args = me.consume_args(4)?;
+                let left = args[0].clone();
+                let middle = args[1].clone();
+                let middle_double = args[2].clone();
+                let right = args[3].clone();
+
+                let content = me.consume_args(1)?;
+                let content = content.into_iter().next().unwrap();
+
+                // Convert stack-order (reversed) to logical order, replace all | at depth 0,
+                // then reverse back to stack order.
+                let logical: Vec<Token> = content.into_iter().rev().collect();
+                let mut new_logical: Vec<Token> = Vec::new();
+                let mut depth: i32 = 0;
+                let mut i = 0;
+                while i < logical.len() {
+                    let t = &logical[i];
+                    if t.text == "{" {
+                        depth += 1;
+                        new_logical.push(t.clone());
+                    } else if t.text == "}" {
+                        depth -= 1;
+                        new_logical.push(t.clone());
+                    } else if depth == 0 && t.text == "|" {
+                        // Check for || (double pipe) → middleDouble
+                        if !middle_double.is_empty()
+                            && i + 1 < logical.len()
+                            && logical[i + 1].text == "|"
+                        {
+                            // middle_double is in stack/reversed order; reverse to logical order
+                            new_logical.extend(middle_double.iter().rev().cloned());
+                            i += 2;
+                            continue;
+                        }
+                        // middle is in stack/reversed order; reverse to logical order
+                        new_logical.extend(middle.iter().rev().cloned());
+                    } else {
+                        new_logical.push(t.clone());
+                    }
+                    i += 1;
+                }
+
+                // Reverse back to stack order
+                let content_rev: Vec<Token> = new_logical.into_iter().rev().collect();
+
+                // Build: right + content + left (reversed for stack)
+                let mut to_expand = Vec::new();
+                to_expand.extend(right);
+                to_expand.extend(content_rev);
+                to_expand.extend(left);
+
+                me.begin_group();
+                let expanded = me.expand_tokens(to_expand)?;
+                me.end_group();
+
+                Ok(expanded)
+            }),
+        );
+
         // \bra@set: braket set notation helper
         // Only replaces the FIRST | with middle tokens (one-shot), matching KaTeX
         self.macros.set(

crates/ratex-render/tests/golden_test.rs

@@ -233,3 +233,4 @@ fn golden_test_pass_rate() {
          Many failures are from unimplemented node types, not rendering bugs."
     );
 }
+