From b09d6ae31c78463ad741644194c17ddd47c2bd56 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Fri, 26 Jan 2024 10:50:33 +0100
Subject: [PATCH] Refactor math styling to bring it closer to normal styling
 (#3262)

---
 crates/typst/src/foundations/styles.rs |  50 ++++-
 crates/typst/src/math/accent.rs        |  30 +--
 crates/typst/src/math/align.rs         |   4 +-
 crates/typst/src/math/attach.rs        | 119 +++++-----
 crates/typst/src/math/cancel.rs        |  14 +-
 crates/typst/src/math/class.rs         |  18 +-
 crates/typst/src/math/ctx.rs           | 244 +++++++++------------
 crates/typst/src/math/equation.rs      |  48 +++-
 crates/typst/src/math/frac.rs          |  72 +++---
 crates/typst/src/math/fragment.rs      | 178 ++++++++-------
 crates/typst/src/math/lr.rs            |  35 +--
 crates/typst/src/math/matrix.rs        |  72 +++---
 crates/typst/src/math/mod.rs           |  61 +++---
 crates/typst/src/math/op.rs            |  14 +-
 crates/typst/src/math/root.rs          |  40 ++--
 crates/typst/src/math/row.rs           |  38 ++--
 crates/typst/src/math/spacing.rs       |   5 +-
 crates/typst/src/math/stretch.rs       |  18 +-
 crates/typst/src/math/style.rs         | 289 ++++++-------------------
 crates/typst/src/math/underover.rs     |  96 ++++----
 tests/ref/math/class.png               | Bin 7599 -> 7545 bytes
 tests/ref/math/equation-show.png       | Bin 0 -> 2428 bytes
 tests/typ/math/equation-show.typ       |   7 +
 23 files changed, 698 insertions(+), 754 deletions(-)
 create mode 100644 tests/ref/math/equation-show.png
 create mode 100644 tests/typ/math/equation-show.typ

diff --git a/crates/typst/src/foundations/styles.rs b/crates/typst/src/foundations/styles.rs
index da8447c3a..f44a320f3 100644
--- a/crates/typst/src/foundations/styles.rs
+++ b/crates/typst/src/foundations/styles.rs
@@ -445,17 +445,16 @@ impl<'a> StyleChain<'a> {
         Self { head: &root.0, tail: None }
     }
 
-    /// Make the given style list the first link of this chain.
+    /// Make the given chainable the first link of this chain.
     ///
     /// The resulting style chain contains styles from `local` as well as
     /// `self`. The ones from `local` take precedence over the ones from
     /// `self`. For folded properties `local` contributes the inner value.
-    pub fn chain<'b>(&'b self, local: &'b Styles) -> StyleChain<'b> {
-        if local.is_empty() {
-            *self
-        } else {
-            StyleChain { head: &local.0, tail: Some(self) }
-        }
+    pub fn chain<'b, C>(&'b self, local: &'b C) -> StyleChain<'b>
+    where
+        C: Chainable,
+    {
+        Chainable::chain(local, self)
     }
 
     /// Cast the first value for the given property in the chain,
@@ -630,6 +629,43 @@ impl PartialEq for StyleChain<'_> {
     }
 }
 
+/// Things that can be attached to a style chain.
+pub trait Chainable {
+    /// Attach `self` as the first link of the chain.
+    fn chain<'a>(&'a self, outer: &'a StyleChain<'_>) -> StyleChain<'a>;
+}
+
+impl Chainable for Prehashed<Style> {
+    fn chain<'a>(&'a self, outer: &'a StyleChain<'_>) -> StyleChain<'a> {
+        StyleChain {
+            head: std::slice::from_ref(self),
+            tail: Some(outer),
+        }
+    }
+}
+
+impl Chainable for [Prehashed<Style>] {
+    fn chain<'a>(&'a self, outer: &'a StyleChain<'_>) -> StyleChain<'a> {
+        if self.is_empty() {
+            *outer
+        } else {
+            StyleChain { head: self, tail: Some(outer) }
+        }
+    }
+}
+
+impl<const N: usize> Chainable for [Prehashed<Style>; N] {
+    fn chain<'a>(&'a self, outer: &'a StyleChain<'_>) -> StyleChain<'a> {
+        Chainable::chain(self.as_slice(), outer)
+    }
+}
+
+impl Chainable for Styles {
+    fn chain<'a>(&'a self, outer: &'a StyleChain<'_>) -> StyleChain<'a> {
+        Chainable::chain(self.0.as_slice(), outer)
+    }
+}
+
 /// An iterator over the entries in a style chain.
 struct Entries<'a> {
     inner: std::slice::Iter<'a, Prehashed<Style>>,
diff --git a/crates/typst/src/math/accent.rs b/crates/typst/src/math/accent.rs
index d325596c1..daf5dffcb 100644
--- a/crates/typst/src/math/accent.rs
+++ b/crates/typst/src/math/accent.rs
@@ -1,10 +1,11 @@
-use unicode_math_class::MathClass;
-
 use crate::diag::{bail, SourceResult};
-use crate::foundations::{cast, elem, Content, Packed, Resolve, Smart, Value};
+use crate::foundations::{
+    cast, elem, Content, Packed, Resolve, Smart, StyleChain, Value,
+};
 use crate::layout::{Em, Frame, Length, Point, Rel, Size};
 use crate::math::{
-    FrameFragment, GlyphFragment, LayoutMath, MathContext, MathFragment, Scaled,
+    style_cramped, FrameFragment, GlyphFragment, LayoutMath, MathContext, MathFragment,
+    Scaled,
 };
 use crate::symbols::Symbol;
 use crate::text::TextElem;
@@ -64,26 +65,25 @@ pub struct AccentElem {
 
 impl LayoutMath for Packed<AccentElem> {
     #[typst_macros::time(name = "math.accent", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        ctx.style(ctx.style.with_cramped(true));
-        let base = ctx.layout_fragment(self.base())?;
-        ctx.unstyle();
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let cramped = style_cramped();
+        let base = ctx.layout_fragment(self.base(), styles.chain(&cramped))?;
 
         // Preserve class to preserve automatic spacing.
-        let base_class = base.class().unwrap_or(MathClass::Normal);
+        let base_class = base.class();
         let base_attach = base.accent_attach();
 
         let width = self
-            .size(ctx.styles())
+            .size(styles)
             .unwrap_or(Rel::one())
-            .resolve(ctx.styles())
+            .resolve(styles)
             .relative_to(base.width());
 
         // Forcing the accent to be at least as large as the base makes it too
         // wide in many case.
         let Accent(c) = self.accent();
-        let glyph = GlyphFragment::new(ctx, *c, self.span());
-        let short_fall = ACCENT_SHORT_FALL.scaled(ctx);
+        let glyph = GlyphFragment::new(ctx, styles, *c, self.span());
+        let short_fall = ACCENT_SHORT_FALL.at(glyph.font_size);
         let variant = glyph.stretch_horizontal(ctx, width, short_fall);
         let accent = variant.frame;
         let accent_attach = variant.accent_attach;
@@ -92,7 +92,7 @@ impl LayoutMath for Packed<AccentElem> {
         // baseline. Therefore, the default gap is the accent's negated descent
         // minus the accent base height. Only if the base is very small, we need
         // a larger gap so that the accent doesn't move too low.
-        let accent_base_height = scaled!(ctx, accent_base_height);
+        let accent_base_height = scaled!(ctx, styles, accent_base_height);
         let gap = -accent.descent() - base.height().min(accent_base_height);
         let size = Size::new(base.width(), accent.height() + gap + base.height());
         let accent_pos = Point::with_x(base_attach - accent_attach);
@@ -111,7 +111,7 @@ impl LayoutMath for Packed<AccentElem> {
         frame.push_frame(accent_pos, accent);
         frame.push_frame(base_pos, base.into_frame());
         ctx.push(
-            FrameFragment::new(ctx, frame)
+            FrameFragment::new(ctx, styles, frame)
                 .with_class(base_class)
                 .with_base_ascent(base_ascent)
                 .with_italics_correction(base_italics_correction)
diff --git a/crates/typst/src/math/align.rs b/crates/typst/src/math/align.rs
index a1d396dab..e7d0fab10 100644
--- a/crates/typst/src/math/align.rs
+++ b/crates/typst/src/math/align.rs
@@ -1,5 +1,5 @@
 use crate::diag::SourceResult;
-use crate::foundations::{elem, Packed};
+use crate::foundations::{elem, Packed, StyleChain};
 use crate::layout::Abs;
 use crate::math::{LayoutMath, MathContext, MathFragment, MathRow};
 
@@ -8,7 +8,7 @@ use crate::math::{LayoutMath, MathContext, MathFragment, MathRow};
 pub struct AlignPointElem {}
 
 impl LayoutMath for Packed<AlignPointElem> {
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, _: StyleChain) -> SourceResult<()> {
         ctx.push(MathFragment::Align);
         Ok(())
     }
diff --git a/crates/typst/src/math/attach.rs b/crates/typst/src/math/attach.rs
index 09541d1ca..d7b3aceed 100644
--- a/crates/typst/src/math/attach.rs
+++ b/crates/typst/src/math/attach.rs
@@ -4,7 +4,8 @@ use crate::diag::SourceResult;
 use crate::foundations::{elem, Content, Packed, StyleChain};
 use crate::layout::{Abs, Frame, Point, Size};
 use crate::math::{
-    FrameFragment, LayoutMath, MathContext, MathFragment, MathSize, Scaled,
+    style_for_subscript, style_for_superscript, EquationElem, FrameFragment, LayoutMath,
+    MathContext, MathFragment, MathSize, Scaled,
 };
 use crate::text::TextElem;
 
@@ -50,32 +51,32 @@ pub struct AttachElem {
 
 impl LayoutMath for Packed<AttachElem> {
     #[typst_macros::time(name = "math.attach", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         type GetAttachment = fn(&AttachElem, styles: StyleChain) -> Option<Content>;
-        let layout_attachment = |ctx: &mut MathContext, getter: GetAttachment| {
-            getter(self, ctx.styles())
-                .map(|elem| ctx.layout_fragment(&elem))
-                .transpose()
-        };
 
-        let base = ctx.layout_fragment(self.base())?;
+        let layout_attachment =
+            |ctx: &mut MathContext, styles: StyleChain, getter: GetAttachment| {
+                getter(self, styles)
+                    .map(|elem| ctx.layout_fragment(&elem, styles))
+                    .transpose()
+            };
 
-        ctx.style(ctx.style.for_superscript());
-        let tl = layout_attachment(ctx, AttachElem::tl)?;
-        let tr = layout_attachment(ctx, AttachElem::tr)?;
-        let t = layout_attachment(ctx, AttachElem::t)?;
-        ctx.unstyle();
+        let base = ctx.layout_fragment(self.base(), styles)?;
 
-        ctx.style(ctx.style.for_subscript());
-        let bl = layout_attachment(ctx, AttachElem::bl)?;
-        let br = layout_attachment(ctx, AttachElem::br)?;
-        let b = layout_attachment(ctx, AttachElem::b)?;
-        ctx.unstyle();
+        let sup_style = style_for_superscript(styles);
+        let tl = layout_attachment(ctx, styles.chain(&sup_style), AttachElem::tl)?;
+        let tr = layout_attachment(ctx, styles.chain(&sup_style), AttachElem::tr)?;
+        let t = layout_attachment(ctx, styles.chain(&sup_style), AttachElem::t)?;
 
-        let limits = base.limits().active(ctx);
+        let sub_style = style_for_subscript(styles);
+        let bl = layout_attachment(ctx, styles.chain(&sub_style), AttachElem::bl)?;
+        let br = layout_attachment(ctx, styles.chain(&sub_style), AttachElem::br)?;
+        let b = layout_attachment(ctx, styles.chain(&sub_style), AttachElem::b)?;
+
+        let limits = base.limits().active(styles);
         let (t, tr) = if limits || tr.is_some() { (t, tr) } else { (None, t) };
         let (b, br) = if limits || br.is_some() { (b, br) } else { (None, b) };
-        layout_attachments(ctx, base, [tl, t, tr, bl, b, br])
+        layout_attachments(ctx, styles, base, [tl, t, tr, bl, b, br])
     }
 }
 
@@ -98,21 +99,23 @@ pub struct PrimesElem {
 
 impl LayoutMath for Packed<PrimesElem> {
     #[typst_macros::time(name = "math.primes", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         match *self.count() {
             count @ 1..=4 => {
-                let f = ctx.layout_fragment(&TextElem::packed(match count {
+                let c = match count {
                     1 => '′',
                     2 => '″',
                     3 => '‴',
                     4 => '⁗',
                     _ => unreachable!(),
-                }))?;
+                };
+                let f = ctx.layout_fragment(&TextElem::packed(c), styles)?;
                 ctx.push(f);
             }
             count => {
                 // Custom amount of primes
-                let prime = ctx.layout_fragment(&TextElem::packed('′'))?.into_frame();
+                let prime =
+                    ctx.layout_fragment(&TextElem::packed('′'), styles)?.into_frame();
                 let width = prime.width() * (count + 1) as f64 / 2.0;
                 let mut frame = Frame::soft(Size::new(width, prime.height()));
                 frame.set_baseline(prime.ascent());
@@ -123,7 +126,7 @@ impl LayoutMath for Packed<PrimesElem> {
                         prime.clone(),
                     )
                 }
-                ctx.push(FrameFragment::new(ctx, frame));
+                ctx.push(FrameFragment::new(ctx, styles, frame));
             }
         }
         Ok(())
@@ -144,8 +147,8 @@ pub struct ScriptsElem {
 
 impl LayoutMath for Packed<ScriptsElem> {
     #[typst_macros::time(name = "math.scripts", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let mut fragment = ctx.layout_fragment(self.body())?;
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let mut fragment = ctx.layout_fragment(self.body(), styles)?;
         fragment.set_limits(Limits::Never);
         ctx.push(fragment);
         Ok(())
@@ -173,13 +176,10 @@ pub struct LimitsElem {
 
 impl LayoutMath for Packed<LimitsElem> {
     #[typst_macros::time(name = "math.limits", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let mut fragment = ctx.layout_fragment(self.body())?;
-        fragment.set_limits(if self.inline(ctx.styles()) {
-            Limits::Always
-        } else {
-            Limits::Display
-        });
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let limits = if self.inline(styles) { Limits::Always } else { Limits::Display };
+        let mut fragment = ctx.layout_fragment(self.body(), styles)?;
+        fragment.set_limits(limits);
         ctx.push(fragment);
         Ok(())
     }
@@ -222,10 +222,10 @@ impl Limits {
     }
 
     /// Whether limits should be displayed in this context
-    pub fn active(&self, ctx: &MathContext) -> bool {
+    pub fn active(&self, styles: StyleChain) -> bool {
         match self {
             Self::Always => true,
-            Self::Display => ctx.style.size == MathSize::Display,
+            Self::Display => EquationElem::size_in(styles) == MathSize::Display,
             Self::Never => false,
         }
     }
@@ -240,17 +240,18 @@ macro_rules! measure {
 /// Layout the attachments.
 fn layout_attachments(
     ctx: &mut MathContext,
+    styles: StyleChain,
     base: MathFragment,
     [tl, t, tr, bl, b, br]: [Option<MathFragment>; 6],
 ) -> SourceResult<()> {
     let (shift_up, shift_down) =
-        compute_shifts_up_and_down(ctx, &base, [&tl, &tr, &bl, &br]);
+        compute_shifts_up_and_down(ctx, styles, &base, [&tl, &tr, &bl, &br]);
 
     let sup_delta = Abs::zero();
     let sub_delta = -base.italics_correction();
     let (base_width, base_ascent, base_descent) =
         (base.width(), base.ascent(), base.descent());
-    let base_class = base.class().unwrap_or(MathClass::Normal);
+    let base_class = base.class();
 
     let mut ascent = base_ascent
         .max(shift_up + measure!(tr, ascent))
@@ -269,9 +270,9 @@ fn layout_attachments(
     let post_width_max =
         (sup_delta + measure!(tr, width)).max(sub_delta + measure!(br, width));
 
-    let (center_frame, base_offset) = attach_top_and_bottom(ctx, base, t, b);
+    let (center_frame, base_offset) = attach_top_and_bottom(ctx, styles, base, t, b);
     if [&tl, &bl, &tr, &br].iter().all(|&e| e.is_none()) {
-        ctx.push(FrameFragment::new(ctx, center_frame).with_class(base_class));
+        ctx.push(FrameFragment::new(ctx, styles, center_frame).with_class(base_class));
         return Ok(());
     }
 
@@ -279,7 +280,10 @@ fn layout_attachments(
     descent.set_max(center_frame.descent());
 
     let mut frame = Frame::soft(Size::new(
-        pre_width_max + base_width + post_width_max + scaled!(ctx, space_after_script),
+        pre_width_max
+            + base_width
+            + post_width_max
+            + scaled!(ctx, styles, space_after_script),
         ascent + descent,
     ));
     frame.set_baseline(ascent);
@@ -316,21 +320,22 @@ fn layout_attachments(
         frame.push_frame(pos, br.into_frame());
     }
 
-    ctx.push(FrameFragment::new(ctx, frame).with_class(base_class));
+    ctx.push(FrameFragment::new(ctx, styles, frame).with_class(base_class));
 
     Ok(())
 }
 
 fn attach_top_and_bottom(
     ctx: &mut MathContext,
+    styles: StyleChain,
     base: MathFragment,
     t: Option<MathFragment>,
     b: Option<MathFragment>,
 ) -> (Frame, Abs) {
-    let upper_gap_min = scaled!(ctx, upper_limit_gap_min);
-    let upper_rise_min = scaled!(ctx, upper_limit_baseline_rise_min);
-    let lower_gap_min = scaled!(ctx, lower_limit_gap_min);
-    let lower_drop_min = scaled!(ctx, lower_limit_baseline_drop_min);
+    let upper_gap_min = scaled!(ctx, styles, upper_limit_gap_min);
+    let upper_rise_min = scaled!(ctx, styles, upper_limit_baseline_rise_min);
+    let lower_gap_min = scaled!(ctx, styles, lower_limit_gap_min);
+    let lower_drop_min = scaled!(ctx, styles, lower_limit_baseline_drop_min);
 
     let mut base_offset = Abs::zero();
     let mut width = base.width();
@@ -372,22 +377,24 @@ fn attach_top_and_bottom(
 
 fn compute_shifts_up_and_down(
     ctx: &MathContext,
+    styles: StyleChain,
     base: &MathFragment,
     [tl, tr, bl, br]: [&Option<MathFragment>; 4],
 ) -> (Abs, Abs) {
-    let sup_shift_up = if ctx.style.cramped {
-        scaled!(ctx, superscript_shift_up_cramped)
+    let sup_shift_up = if EquationElem::cramped_in(styles) {
+        scaled!(ctx, styles, superscript_shift_up_cramped)
     } else {
-        scaled!(ctx, superscript_shift_up)
+        scaled!(ctx, styles, superscript_shift_up)
     };
 
-    let sup_bottom_min = scaled!(ctx, superscript_bottom_min);
-    let sup_bottom_max_with_sub = scaled!(ctx, superscript_bottom_max_with_subscript);
-    let sup_drop_max = scaled!(ctx, superscript_baseline_drop_max);
-    let gap_min = scaled!(ctx, sub_superscript_gap_min);
-    let sub_shift_down = scaled!(ctx, subscript_shift_down);
-    let sub_top_max = scaled!(ctx, subscript_top_max);
-    let sub_drop_min = scaled!(ctx, subscript_baseline_drop_min);
+    let sup_bottom_min = scaled!(ctx, styles, superscript_bottom_min);
+    let sup_bottom_max_with_sub =
+        scaled!(ctx, styles, superscript_bottom_max_with_subscript);
+    let sup_drop_max = scaled!(ctx, styles, superscript_baseline_drop_max);
+    let gap_min = scaled!(ctx, styles, sub_superscript_gap_min);
+    let sub_shift_down = scaled!(ctx, styles, subscript_shift_down);
+    let sub_top_max = scaled!(ctx, styles, subscript_top_max);
+    let sub_drop_min = scaled!(ctx, styles, subscript_baseline_drop_min);
 
     let mut shift_up = Abs::zero();
     let mut shift_down = Abs::zero();
diff --git a/crates/typst/src/math/cancel.rs b/crates/typst/src/math/cancel.rs
index e01b98ca1..039ef752a 100644
--- a/crates/typst/src/math/cancel.rs
+++ b/crates/typst/src/math/cancel.rs
@@ -1,7 +1,5 @@
-use unicode_math_class::MathClass;
-
 use crate::diag::{At, SourceResult};
-use crate::foundations::{cast, elem, Content, Func, Packed, Resolve, Smart};
+use crate::foundations::{cast, elem, Content, Func, Packed, Resolve, Smart, StyleChain};
 use crate::layout::{
     Abs, Angle, Frame, FrameItem, Length, Point, Ratio, Rel, Size, Transform,
 };
@@ -107,17 +105,15 @@ pub struct CancelElem {
 
 impl LayoutMath for Packed<CancelElem> {
     #[typst_macros::time(name = "math.cancel", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let body = ctx.layout_fragment(self.body())?;
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let body = ctx.layout_fragment(self.body(), styles)?;
         // Preserve properties of body.
-        let body_class = body.class().unwrap_or(MathClass::Special);
+        let body_class = body.class();
         let body_italics = body.italics_correction();
         let body_attach = body.accent_attach();
         let body_text_like = body.is_text_like();
 
         let mut body = body.into_frame();
-
-        let styles = ctx.styles();
         let body_size = body.size();
         let span = self.span();
         let length = self.length(styles).resolve(styles);
@@ -155,7 +151,7 @@ impl LayoutMath for Packed<CancelElem> {
         }
 
         ctx.push(
-            FrameFragment::new(ctx, body)
+            FrameFragment::new(ctx, styles, body)
                 .with_class(body_class)
                 .with_italics_correction(body_italics)
                 .with_accent_attach(body_attach)
diff --git a/crates/typst/src/math/class.rs b/crates/typst/src/math/class.rs
index 1b6c638ca..50aabede4 100644
--- a/crates/typst/src/math/class.rs
+++ b/crates/typst/src/math/class.rs
@@ -1,8 +1,9 @@
+use comemo::Prehashed;
 use unicode_math_class::MathClass;
 
 use crate::diag::SourceResult;
-use crate::foundations::{elem, Content, Packed};
-use crate::math::{LayoutMath, Limits, MathContext};
+use crate::foundations::{elem, Content, Packed, StyleChain};
+use crate::math::{EquationElem, LayoutMath, Limits, MathContext};
 
 /// Forced use of a certain math class.
 ///
@@ -34,13 +35,12 @@ pub struct ClassElem {
 
 impl LayoutMath for Packed<ClassElem> {
     #[typst_macros::time(name = "math.class", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        ctx.style(ctx.style.with_class(*self.class()));
-        let mut fragment = ctx.layout_fragment(self.body())?;
-        ctx.unstyle();
-
-        fragment.set_class(*self.class());
-        fragment.set_limits(Limits::for_class(*self.class()));
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let class = *self.class();
+        let style = Prehashed::new(EquationElem::set_class(Some(class)));
+        let mut fragment = ctx.layout_fragment(self.body(), styles.chain(&style))?;
+        fragment.set_class(class);
+        fragment.set_limits(Limits::for_class(class));
         ctx.push(fragment);
         Ok(())
     }
diff --git a/crates/typst/src/math/ctx.rs b/crates/typst/src/math/ctx.rs
index 5842aae0d..5b4227b40 100644
--- a/crates/typst/src/math/ctx.rs
+++ b/crates/typst/src/math/ctx.rs
@@ -12,29 +12,30 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::SourceResult;
 use crate::engine::Engine;
-use crate::foundations::{Content, Packed, Smart, StyleChain, Styles};
+use crate::foundations::{Content, Packed, Smart, StyleChain};
 use crate::layout::{Abs, Axes, BoxElem, Em, Frame, LayoutMultiple, Regions, Size};
 use crate::math::{
-    FrameFragment, GlyphFragment, LayoutMath, MathFragment, MathRow, MathSize, MathStyle,
-    MathVariant, THICK,
+    scaled_font_size, styled_char, EquationElem, FrameFragment, GlyphFragment,
+    LayoutMath, MathFragment, MathRow, MathSize, THICK,
 };
 use crate::model::ParElem;
-use crate::realize::realize;
 use crate::syntax::{is_newline, Span};
 use crate::text::{
-    features, variant, BottomEdge, BottomEdgeMetric, Font, FontStyle, FontWeight,
-    TextElem, TextSize, TopEdge, TopEdgeMetric,
+    features, BottomEdge, BottomEdgeMetric, Font, TextElem, TextSize, TopEdge,
+    TopEdgeMetric,
 };
 
 macro_rules! scaled {
-    ($ctx:expr, text: $text:ident, display: $display:ident $(,)?) => {
-        match $ctx.style.size {
-            MathSize::Display => scaled!($ctx, $display),
-            _ => scaled!($ctx, $text),
+    ($ctx:expr, $styles:expr, text: $text:ident, display: $display:ident $(,)?) => {
+        match $crate::math::EquationElem::size_in($styles) {
+            $crate::math::MathSize::Display => scaled!($ctx, $styles, $display),
+            _ => scaled!($ctx, $styles, $text),
         }
     };
-    ($ctx:expr, $name:ident) => {
-        $ctx.constants.$name().scaled($ctx)
+    ($ctx:expr, $styles:expr, $name:ident) => {
+        $ctx.constants
+            .$name()
+            .scaled($ctx, $crate::math::scaled_font_size($ctx, $styles))
     };
 }
 
@@ -46,8 +47,10 @@ macro_rules! percent {
 
 /// The context for math layout.
 pub struct MathContext<'a, 'b, 'v> {
+    // External.
     pub engine: &'v mut Engine<'b>,
     pub regions: Regions<'static>,
+    // Font-related.
     pub font: &'a Font,
     pub ttf: &'a ttf_parser::Face<'a>,
     pub table: ttf_parser::math::Table<'a>,
@@ -55,12 +58,8 @@ pub struct MathContext<'a, 'b, 'v> {
     pub ssty_table: Option<ttf_parser::gsub::AlternateSubstitution<'a>>,
     pub glyphwise_tables: Option<Vec<GlyphwiseSubsts<'a>>>,
     pub space_width: Em,
+    // Mutable.
     pub fragments: Vec<MathFragment>,
-    pub local: Styles,
-    pub style: MathStyle,
-    pub size: Abs,
-    outer: StyleChain<'a>,
-    style_stack: Vec<(MathStyle, Abs)>,
 }
 
 impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
@@ -69,7 +68,6 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
         styles: StyleChain<'a>,
         regions: Regions,
         font: &'a Font,
-        block: bool,
     ) -> Self {
         let math_table = font.ttf().tables().math.unwrap();
         let gsub_table = font.ttf().tables().gsub;
@@ -96,7 +94,6 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
                 .collect()
         });
 
-        let size = TextElem::size_in(styles);
         let ttf = font.ttf();
         let space_width = ttf
             .glyph_index(' ')
@@ -104,7 +101,6 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
             .map(|advance| font.to_em(advance))
             .unwrap_or(THICK);
 
-        let variant = variant(styles);
         Self {
             engine,
             regions: Regions::one(regions.base(), Axes::splat(false)),
@@ -116,21 +112,6 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
             glyphwise_tables,
             space_width,
             fragments: vec![],
-            local: Styles::new(),
-            style: MathStyle {
-                variant: MathVariant::Serif,
-                size: if block { MathSize::Display } else { MathSize::Text },
-                class: Smart::Auto,
-                cramped: false,
-                bold: variant.weight >= FontWeight::BOLD,
-                italic: match variant.style {
-                    FontStyle::Normal => Smart::Auto,
-                    FontStyle::Italic | FontStyle::Oblique => Smart::Custom(true),
-                },
-            },
-            size,
-            outer: styles,
-            style_stack: vec![],
         }
     }
 
@@ -142,59 +123,92 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
         self.fragments.extend(fragments);
     }
 
-    pub fn layout_root(&mut self, elem: &dyn LayoutMath) -> SourceResult<MathRow> {
-        let row = self.layout_fragments(elem)?;
+    pub fn layout_root(
+        &mut self,
+        elem: &dyn LayoutMath,
+        styles: StyleChain,
+    ) -> SourceResult<MathRow> {
+        let row = self.layout_fragments(elem, styles)?;
         Ok(MathRow::new(row))
     }
 
     pub fn layout_fragment(
         &mut self,
         elem: &dyn LayoutMath,
+        styles: StyleChain,
     ) -> SourceResult<MathFragment> {
-        let row = self.layout_fragments(elem)?;
-        Ok(MathRow::new(row).into_fragment(self))
+        let row = self.layout_fragments(elem, styles)?;
+        Ok(MathRow::new(row).into_fragment(self, styles))
     }
 
     pub fn layout_fragments(
         &mut self,
         elem: &dyn LayoutMath,
+        styles: StyleChain,
     ) -> SourceResult<Vec<MathFragment>> {
         let prev = std::mem::take(&mut self.fragments);
-        elem.layout_math(self)?;
+        elem.layout_math(self, styles)?;
         Ok(std::mem::replace(&mut self.fragments, prev))
     }
 
-    pub fn layout_row(&mut self, elem: &dyn LayoutMath) -> SourceResult<MathRow> {
-        let fragments = self.layout_fragments(elem)?;
+    pub fn layout_row(
+        &mut self,
+        elem: &dyn LayoutMath,
+        styles: StyleChain,
+    ) -> SourceResult<MathRow> {
+        let fragments = self.layout_fragments(elem, styles)?;
         Ok(MathRow::new(fragments))
     }
 
-    pub fn layout_frame(&mut self, elem: &dyn LayoutMath) -> SourceResult<Frame> {
-        Ok(self.layout_fragment(elem)?.into_frame())
+    pub fn layout_frame(
+        &mut self,
+        elem: &dyn LayoutMath,
+        styles: StyleChain,
+    ) -> SourceResult<Frame> {
+        Ok(self.layout_fragment(elem, styles)?.into_frame())
     }
 
-    pub fn layout_box(&mut self, boxed: &Packed<BoxElem>) -> SourceResult<Frame> {
-        boxed.layout(self.engine, self.outer.chain(&self.local), self.regions)
+    pub fn layout_box(
+        &mut self,
+        boxed: &Packed<BoxElem>,
+        styles: StyleChain,
+    ) -> SourceResult<Frame> {
+        let local = Prehashed::new(TextElem::set_size(TextSize(
+            scaled_font_size(self, styles).into(),
+        )));
+        boxed.layout(self.engine, styles.chain(&local), self.regions)
     }
 
-    pub fn layout_content(&mut self, content: &Content) -> SourceResult<Frame> {
+    pub fn layout_content(
+        &mut self,
+        content: &Content,
+        styles: StyleChain,
+    ) -> SourceResult<Frame> {
+        let local = Prehashed::new(TextElem::set_size(TextSize(
+            scaled_font_size(self, styles).into(),
+        )));
         Ok(content
-            .layout(self.engine, self.outer.chain(&self.local), self.regions)?
+            .layout(self.engine, styles.chain(&local), self.regions)?
             .into_frame())
     }
 
-    pub fn layout_text(&mut self, elem: &Packed<TextElem>) -> SourceResult<MathFragment> {
+    pub fn layout_text(
+        &mut self,
+        elem: &Packed<TextElem>,
+        styles: StyleChain,
+    ) -> SourceResult<MathFragment> {
         let text = elem.text();
         let span = elem.span();
         let mut chars = text.chars();
+        let math_size = EquationElem::size_in(styles);
         let fragment = if let Some(mut glyph) = chars
             .next()
             .filter(|_| chars.next().is_none())
-            .map(|c| self.style.styled_char(c))
-            .and_then(|c| GlyphFragment::try_new(self, c, span))
+            .map(|c| styled_char(styles, c))
+            .and_then(|c| GlyphFragment::try_new(self, styles, c, span))
         {
             // A single letter that is available in the math font.
-            match self.style.size {
+            match math_size {
                 MathSize::Script => {
                     glyph.make_scriptsize(self);
                 }
@@ -204,10 +218,9 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
                 _ => (),
             }
 
-            let class = self.style.class.as_custom().or(glyph.class);
-            if class == Some(MathClass::Large) {
-                let mut variant = if self.style.size == MathSize::Display {
-                    let height = scaled!(self, display_operator_min_height)
+            if glyph.class == MathClass::Large {
+                let mut variant = if math_size == MathSize::Display {
+                    let height = scaled!(self, styles, display_operator_min_height)
                         .max(SQRT_2 * glyph.height());
                     glyph.stretch_vertical(self, height, Abs::zero())
                 } else {
@@ -223,18 +236,23 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
             // Numbers aren't that difficult.
             let mut fragments = vec![];
             for c in text.chars() {
-                let c = self.style.styled_char(c);
-                fragments.push(GlyphFragment::new(self, c, span).into());
+                let c = styled_char(styles, c);
+                fragments.push(GlyphFragment::new(self, styles, c, span).into());
             }
-            let frame = MathRow::new(fragments).into_frame(self);
-            FrameFragment::new(self, frame).with_text_like(true).into()
+            let frame = MathRow::new(fragments).into_frame(self, styles);
+            FrameFragment::new(self, styles, frame).with_text_like(true).into()
         } else {
+            let local = [
+                TextElem::set_top_edge(TopEdge::Metric(TopEdgeMetric::Bounds)),
+                TextElem::set_bottom_edge(BottomEdge::Metric(BottomEdgeMetric::Bounds)),
+                TextElem::set_size(TextSize(scaled_font_size(self, styles).into())),
+                EquationElem::set_italic(Smart::Custom(false)),
+            ]
+            .map(Prehashed::new);
+
             // Anything else is handled by Typst's standard text layout.
-            let mut style = self.style;
-            if self.style.italic == Smart::Auto {
-                style = style.with_italic(false);
-            }
-            let text: EcoString = text.chars().map(|c| style.styled_char(c)).collect();
+            let styles = styles.chain(&local);
+            let text: EcoString = text.chars().map(|c| styled_char(styles, c)).collect();
             if text.contains(is_newline) {
                 let mut fragments = vec![];
                 for (i, piece) in text.split(is_newline).enumerate() {
@@ -242,117 +260,65 @@ impl<'a, 'b, 'v> MathContext<'a, 'b, 'v> {
                         fragments.push(MathFragment::Linebreak);
                     }
                     if !piece.is_empty() {
-                        fragments.push(self.layout_complex_text(piece, span)?.into());
+                        fragments
+                            .push(self.layout_complex_text(piece, span, styles)?.into());
                     }
                 }
-                let mut frame = MathRow::new(fragments).into_frame(self);
-                let axis = scaled!(self, axis_height);
+                let mut frame = MathRow::new(fragments).into_frame(self, styles);
+                let axis = scaled!(self, styles, axis_height);
                 frame.set_baseline(frame.height() / 2.0 + axis);
-                FrameFragment::new(self, frame).into()
+                FrameFragment::new(self, styles, frame).into()
             } else {
-                self.layout_complex_text(&text, span)?.into()
+                self.layout_complex_text(&text, span, styles)?.into()
             }
         };
         Ok(fragment)
     }
 
-    pub fn layout_complex_text(
+    fn layout_complex_text(
         &mut self,
         text: &str,
         span: Span,
+        styles: StyleChain,
     ) -> SourceResult<FrameFragment> {
-        let spaced = text.graphemes(true).nth(1).is_some();
-        let elem = TextElem::packed(text)
-            .styled(TextElem::set_top_edge(TopEdge::Metric(TopEdgeMetric::Bounds)))
-            .styled(TextElem::set_bottom_edge(BottomEdge::Metric(
-                BottomEdgeMetric::Bounds,
-            )))
-            .spanned(span);
-
         // There isn't a natural width for a paragraph in a math environment;
         // because it will be placed somewhere probably not at the left margin
-        // it will overflow.  So emulate an `hbox` instead and allow the paragraph
+        // it will overflow. So emulate an `hbox` instead and allow the paragraph
         // to extend as far as needed.
-        let span = elem.span();
-        let frame = Packed::new(ParElem::new(vec![Prehashed::new(elem)]))
+        let spaced = text.graphemes(true).nth(1).is_some();
+        let text = TextElem::packed(text).spanned(span);
+        let par = ParElem::new(vec![Prehashed::new(text)]);
+        let frame = Packed::new(par)
             .spanned(span)
-            .layout(
-                self.engine,
-                self.outer.chain(&self.local),
-                false,
-                Size::splat(Abs::inf()),
-                false,
-            )?
+            .layout(self.engine, styles, false, Size::splat(Abs::inf()), false)?
             .into_frame();
 
-        Ok(FrameFragment::new(self, frame)
+        Ok(FrameFragment::new(self, styles, frame)
             .with_class(MathClass::Alphabetic)
             .with_text_like(true)
             .with_spaced(spaced))
     }
-
-    pub fn styles(&self) -> StyleChain {
-        self.outer.chain(&self.local)
-    }
-
-    pub fn realize(&mut self, content: &Content) -> SourceResult<Option<Content>> {
-        realize(self.engine, content, self.outer.chain(&self.local))
-    }
-
-    pub fn style(&mut self, style: MathStyle) {
-        self.style_stack.push((self.style, self.size));
-        let base_size = TextElem::size_in(self.styles()) / self.style.size.factor(self);
-        self.size = base_size * style.size.factor(self);
-        self.local.set(TextElem::set_size(TextSize(self.size.into())));
-        self.local
-            .set(TextElem::set_style(if style.italic == Smart::Custom(true) {
-                FontStyle::Italic
-            } else {
-                FontStyle::Normal
-            }));
-        self.local.set(TextElem::set_weight(if style.bold {
-            FontWeight::BOLD
-        } else {
-            // The normal weight is what we started with.
-            // It's 400 for CM Regular, 450 for CM Book.
-            self.font.info().variant.weight
-        }));
-        self.style = style;
-    }
-
-    pub fn unstyle(&mut self) {
-        (self.style, self.size) = self.style_stack.pop().unwrap();
-        self.local.unset();
-        self.local.unset();
-        self.local.unset();
-    }
 }
 
 pub(super) trait Scaled {
-    fn scaled(self, ctx: &MathContext) -> Abs;
+    fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs;
 }
 
 impl Scaled for i16 {
-    fn scaled(self, ctx: &MathContext) -> Abs {
-        ctx.font.to_em(self).scaled(ctx)
+    fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs {
+        ctx.font.to_em(self).at(font_size)
     }
 }
 
 impl Scaled for u16 {
-    fn scaled(self, ctx: &MathContext) -> Abs {
-        ctx.font.to_em(self).scaled(ctx)
-    }
-}
-
-impl Scaled for Em {
-    fn scaled(self, ctx: &MathContext) -> Abs {
-        self.at(ctx.size)
+    fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs {
+        ctx.font.to_em(self).at(font_size)
     }
 }
 
 impl Scaled for MathValue<'_> {
-    fn scaled(self, ctx: &MathContext) -> Abs {
-        self.value.scaled(ctx)
+    fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs {
+        self.value.scaled(ctx, font_size)
     }
 }
 
diff --git a/crates/typst/src/math/equation.rs b/crates/typst/src/math/equation.rs
index 227fdc3fa..fa7e22ab7 100644
--- a/crates/typst/src/math/equation.rs
+++ b/crates/typst/src/math/equation.rs
@@ -1,5 +1,7 @@
 use std::num::NonZeroUsize;
 
+use unicode_math_class::MathClass;
+
 use crate::diag::{bail, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
@@ -11,7 +13,7 @@ use crate::layout::{
     Abs, AlignElem, Alignment, Axes, Dir, Em, FixedAlignment, Frame, LayoutMultiple,
     LayoutSingle, Point, Regions, Size,
 };
-use crate::math::{LayoutMath, MathContext};
+use crate::math::{scaled_font_size, LayoutMath, MathContext, MathSize, MathVariant};
 use crate::model::{Numbering, Outlinable, ParElem, Refable, Supplement};
 use crate::syntax::Span;
 use crate::text::{
@@ -94,6 +96,33 @@ pub struct EquationElem {
     /// The contents of the equation.
     #[required]
     pub body: Content,
+
+    /// The size of the glyphs.
+    #[internal]
+    #[default(MathSize::Text)]
+    pub size: MathSize,
+
+    /// The style variant to select.
+    #[internal]
+    pub variant: MathVariant,
+
+    /// Affects the height of exponents.
+    #[internal]
+    #[default(false)]
+    pub cramped: bool,
+
+    /// Whether to use bold glyphs.
+    #[internal]
+    #[default(false)]
+    pub bold: bool,
+
+    /// Whether to use italic glyphs.
+    #[internal]
+    pub italic: Smart<bool>,
+
+    /// A forced class to use for all fragment.
+    #[internal]
+    pub class: Option<MathClass>,
 }
 
 impl Synthesize for Packed<EquationElem> {
@@ -124,6 +153,7 @@ impl Finalize for Packed<EquationElem> {
         let mut realized = realized;
         if self.block(style) {
             realized = realized.styled(AlignElem::set_alignment(Alignment::CENTER));
+            realized = realized.styled(EquationElem::set_size(MathSize::Display));
         }
         realized
             .styled(TextElem::set_weight(FontWeight::from_number(450)))
@@ -162,19 +192,19 @@ impl Packed<EquationElem> {
         // Find a math font.
         let font = find_math_font(engine, styles, self.span())?;
 
-        let mut ctx = MathContext::new(engine, styles, regions, &font, false);
-        let rows = ctx.layout_root(self)?;
+        let mut ctx = MathContext::new(engine, styles, regions, &font);
+        let rows = ctx.layout_root(self, styles)?;
 
         let mut items = if rows.row_count() == 1 {
             rows.into_par_items()
         } else {
-            vec![MathParItem::Frame(rows.into_fragment(&ctx).into_frame())]
+            vec![MathParItem::Frame(rows.into_fragment(&ctx, styles).into_frame())]
         };
 
         for item in &mut items {
             let MathParItem::Frame(frame) = item else { continue };
 
-            let font_size = TextElem::size_in(styles);
+            let font_size = scaled_font_size(&ctx, styles);
             let slack = ParElem::leading_in(styles) * 0.7;
             let top_edge = TextElem::top_edge_in(styles).resolve(font_size, &font, None);
             let bottom_edge =
@@ -205,8 +235,8 @@ impl LayoutSingle for Packed<EquationElem> {
         // Find a math font.
         let font = find_math_font(engine, styles, self.span())?;
 
-        let mut ctx = MathContext::new(engine, styles, regions, &font, true);
-        let mut frame = ctx.layout_frame(self)?;
+        let mut ctx = MathContext::new(engine, styles, regions, &font);
+        let mut frame = ctx.layout_frame(self, styles)?;
 
         if let Some(numbering) = (**self).numbering(styles) {
             let pod = Regions::one(regions.base(), Axes::splat(false));
@@ -341,8 +371,8 @@ impl Outlinable for Packed<EquationElem> {
 
 impl LayoutMath for Packed<EquationElem> {
     #[typst_macros::time(name = "math.equation", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        self.body().layout_math(ctx)
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        self.body().layout_math(ctx, styles)
     }
 }
 
diff --git a/crates/typst/src/math/frac.rs b/crates/typst/src/math/frac.rs
index 50185de2f..8ea2d09b0 100644
--- a/crates/typst/src/math/frac.rs
+++ b/crates/typst/src/math/frac.rs
@@ -1,9 +1,9 @@
 use crate::diag::{bail, SourceResult};
-use crate::foundations::{elem, Content, Packed, Value};
+use crate::foundations::{elem, Content, Packed, StyleChain, Value};
 use crate::layout::{Em, Frame, FrameItem, Point, Size};
 use crate::math::{
-    FrameFragment, GlyphFragment, LayoutMath, MathContext, MathSize, Scaled,
-    DELIM_SHORT_FALL,
+    scaled_font_size, style_for_denominator, style_for_numerator, FrameFragment,
+    GlyphFragment, LayoutMath, MathContext, Scaled, DELIM_SHORT_FALL,
 };
 use crate::syntax::{Span, Spanned};
 use crate::text::TextElem;
@@ -37,8 +37,15 @@ pub struct FracElem {
 
 impl LayoutMath for Packed<FracElem> {
     #[typst_macros::time(name = "math.frac", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        layout(ctx, self.num(), std::slice::from_ref(self.denom()), false, self.span())
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        layout(
+            ctx,
+            styles,
+            self.num(),
+            std::slice::from_ref(self.denom()),
+            false,
+            self.span(),
+        )
     }
 }
 
@@ -71,55 +78,58 @@ pub struct BinomElem {
 
 impl LayoutMath for Packed<BinomElem> {
     #[typst_macros::time(name = "math.binom", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        layout(ctx, self.upper(), self.lower(), true, self.span())
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        layout(ctx, styles, self.upper(), self.lower(), true, self.span())
     }
 }
 
 /// Layout a fraction or binomial.
 fn layout(
     ctx: &mut MathContext,
+    styles: StyleChain,
     num: &Content,
     denom: &[Content],
     binom: bool,
     span: Span,
 ) -> SourceResult<()> {
-    let short_fall = DELIM_SHORT_FALL.scaled(ctx);
-    let axis = scaled!(ctx, axis_height);
-    let thickness = scaled!(ctx, fraction_rule_thickness);
+    let font_size = scaled_font_size(ctx, styles);
+    let short_fall = DELIM_SHORT_FALL.at(font_size);
+    let axis = scaled!(ctx, styles, axis_height);
+    let thickness = scaled!(ctx, styles, fraction_rule_thickness);
     let shift_up = scaled!(
-        ctx,
+        ctx, styles,
         text: fraction_numerator_shift_up,
         display: fraction_numerator_display_style_shift_up,
     );
     let shift_down = scaled!(
-        ctx,
+        ctx, styles,
         text: fraction_denominator_shift_down,
         display: fraction_denominator_display_style_shift_down,
     );
     let num_min = scaled!(
-        ctx,
+        ctx, styles,
         text: fraction_numerator_gap_min,
         display: fraction_num_display_style_gap_min,
     );
     let denom_min = scaled!(
-        ctx,
+        ctx, styles,
         text: fraction_denominator_gap_min,
         display: fraction_denom_display_style_gap_min,
     );
 
-    ctx.style(ctx.style.for_numerator());
-    let num = ctx.layout_frame(num)?;
-    ctx.unstyle();
+    let num_style = style_for_numerator(styles);
+    let num = ctx.layout_frame(num, styles.chain(&num_style))?;
 
-    ctx.style(ctx.style.for_denominator());
-    let denom = ctx.layout_frame(&Content::sequence(
-        // Add a comma between each element.
-        denom.iter().flat_map(|a| [TextElem::packed(','), a.clone()]).skip(1),
-    ))?;
-    ctx.unstyle();
+    let denom_style = style_for_denominator(styles);
+    let denom = ctx.layout_frame(
+        &Content::sequence(
+            // Add a comma between each element.
+            denom.iter().flat_map(|a| [TextElem::packed(','), a.clone()]).skip(1),
+        ),
+        styles.chain(&denom_style),
+    )?;
 
-    let around = FRAC_AROUND.scaled(ctx);
+    let around = FRAC_AROUND.at(font_size);
     let num_gap = (shift_up - axis - num.descent()).max(num_min + thickness / 2.0);
     let denom_gap = (shift_down + axis - denom.ascent()).max(denom_min + thickness / 2.0);
 
@@ -139,13 +149,13 @@ fn layout(
     frame.push_frame(denom_pos, denom);
 
     if binom {
-        let mut left =
-            GlyphFragment::new(ctx, '(', span).stretch_vertical(ctx, height, short_fall);
+        let mut left = GlyphFragment::new(ctx, styles, '(', span)
+            .stretch_vertical(ctx, height, short_fall);
         left.center_on_axis(ctx);
         ctx.push(left);
-        ctx.push(FrameFragment::new(ctx, frame));
-        let mut right =
-            GlyphFragment::new(ctx, ')', span).stretch_vertical(ctx, height, short_fall);
+        ctx.push(FrameFragment::new(ctx, styles, frame));
+        let mut right = GlyphFragment::new(ctx, styles, ')', span)
+            .stretch_vertical(ctx, height, short_fall);
         right.center_on_axis(ctx);
         ctx.push(right);
     } else {
@@ -154,14 +164,14 @@ fn layout(
             FrameItem::Shape(
                 Geometry::Line(Point::with_x(line_width)).stroked(
                     FixedStroke::from_pair(
-                        TextElem::fill_in(ctx.styles()).as_decoration(),
+                        TextElem::fill_in(styles).as_decoration(),
                         thickness,
                     ),
                 ),
                 span,
             ),
         );
-        ctx.push(FrameFragment::new(ctx, frame));
+        ctx.push(FrameFragment::new(ctx, styles, frame));
     }
 
     Ok(())
diff --git a/crates/typst/src/math/fragment.rs b/crates/typst/src/math/fragment.rs
index 64bc30784..e78cd95ac 100644
--- a/crates/typst/src/math/fragment.rs
+++ b/crates/typst/src/math/fragment.rs
@@ -5,10 +5,12 @@ use ttf_parser::gsub::AlternateSet;
 use ttf_parser::{GlyphId, Rect};
 use unicode_math_class::MathClass;
 
-use crate::foundations::Smart;
+use crate::foundations::StyleChain;
 use crate::introspection::{Meta, MetaElem};
 use crate::layout::{Abs, Corner, Em, Frame, FrameItem, Point, Size};
-use crate::math::{Limits, MathContext, MathStyle, Scaled};
+use crate::math::{
+    scaled_font_size, styled_char, EquationElem, Limits, MathContext, MathSize, Scaled,
+};
 use crate::syntax::Span;
 use crate::text::{Font, Glyph, Lang, TextElem, TextItem};
 use crate::visualize::Paint;
@@ -67,20 +69,23 @@ impl MathFragment {
         }
     }
 
-    pub fn class(&self) -> Option<MathClass> {
-        self.style().and_then(|style| style.class.as_custom()).or(match self {
+    pub fn class(&self) -> MathClass {
+        match self {
             Self::Glyph(glyph) => glyph.class,
             Self::Variant(variant) => variant.class,
-            Self::Frame(fragment) => Some(fragment.class),
-            _ => None,
-        })
+            Self::Frame(fragment) => fragment.class,
+            Self::Spacing(_) => MathClass::Space,
+            Self::Space(_) => MathClass::Space,
+            Self::Linebreak => MathClass::Space,
+            Self::Align => MathClass::Special,
+        }
     }
 
-    pub fn style(&self) -> Option<MathStyle> {
+    pub fn math_size(&self) -> Option<MathSize> {
         match self {
-            Self::Glyph(glyph) => Some(glyph.style),
-            Self::Variant(variant) => Some(variant.style),
-            Self::Frame(fragment) => Some(fragment.style),
+            Self::Glyph(glyph) => Some(glyph.math_size),
+            Self::Variant(variant) => Some(variant.math_size),
+            Self::Frame(fragment) => Some(fragment.math_size),
             _ => None,
         }
     }
@@ -95,27 +100,10 @@ impl MathFragment {
     }
 
     pub fn set_class(&mut self, class: MathClass) {
-        macro_rules! set_style_class {
-            ($fragment:ident) => {
-                if $fragment.style.class.is_custom() {
-                    $fragment.style.class = Smart::Custom(class);
-                }
-            };
-        }
-
         match self {
-            Self::Glyph(glyph) => {
-                glyph.class = Some(class);
-                set_style_class!(glyph);
-            }
-            Self::Variant(variant) => {
-                variant.class = Some(class);
-                set_style_class!(variant);
-            }
-            Self::Frame(fragment) => {
-                fragment.class = class;
-                set_style_class!(fragment);
-            }
+            Self::Glyph(glyph) => glyph.class = class,
+            Self::Variant(variant) => variant.class = class,
+            Self::Frame(fragment) => fragment.class = class,
             _ => {}
         }
     }
@@ -130,21 +118,22 @@ impl MathFragment {
     }
 
     pub fn is_spaced(&self) -> bool {
-        match self {
-            MathFragment::Frame(frame) => {
-                match self.style().and_then(|style| style.class.as_custom()) {
-                    Some(MathClass::Fence) => true,
-                    Some(_) => false,
-                    None => frame.spaced,
+        self.class() == MathClass::Fence
+            || match self {
+                MathFragment::Frame(frame) => {
+                    frame.spaced
+                        && matches!(
+                            frame.class,
+                            MathClass::Normal | MathClass::Alphabetic
+                        )
                 }
+                _ => false,
             }
-            _ => self.class() == Some(MathClass::Fence),
-        }
     }
 
     pub fn is_text_like(&self) -> bool {
         match self {
-            Self::Glyph(_) | Self::Variant(_) => self.class() != Some(MathClass::Large),
+            Self::Glyph(_) | Self::Variant(_) => self.class() != MathClass::Large,
             MathFragment::Frame(frame) => frame.text_like,
             _ => false,
         }
@@ -224,43 +213,57 @@ pub struct GlyphFragment {
     pub descent: Abs,
     pub italics_correction: Abs,
     pub accent_attach: Abs,
-    pub style: MathStyle,
     pub font_size: Abs,
-    pub class: Option<MathClass>,
+    pub class: MathClass,
+    pub math_size: MathSize,
     pub span: Span,
     pub meta: SmallVec<[Meta; 1]>,
     pub limits: Limits,
 }
 
 impl GlyphFragment {
-    pub fn new(ctx: &MathContext, c: char, span: Span) -> Self {
+    pub fn new(ctx: &MathContext, styles: StyleChain, c: char, span: Span) -> Self {
         let id = ctx.ttf.glyph_index(c).unwrap_or_default();
         let id = Self::adjust_glyph_index(ctx, id);
-        Self::with_id(ctx, c, id, span)
+        Self::with_id(ctx, styles, c, id, span)
     }
 
-    pub fn try_new(ctx: &MathContext, c: char, span: Span) -> Option<Self> {
-        let c = ctx.style.styled_char(c);
+    pub fn try_new(
+        ctx: &MathContext,
+        styles: StyleChain,
+        c: char,
+        span: Span,
+    ) -> Option<Self> {
+        let c = styled_char(styles, c);
         let id = ctx.ttf.glyph_index(c)?;
         let id = Self::adjust_glyph_index(ctx, id);
-        Some(Self::with_id(ctx, c, id, span))
+        Some(Self::with_id(ctx, styles, c, id, span))
     }
 
-    pub fn with_id(ctx: &MathContext, c: char, id: GlyphId, span: Span) -> Self {
-        let class = match c {
-            ':' => Some(MathClass::Relation),
-            '.' | '/' | '⋯' | '⋱' | '⋰' | '⋮' => Some(MathClass::Normal),
-            _ => unicode_math_class::class(c),
-        };
+    pub fn with_id(
+        ctx: &MathContext,
+        styles: StyleChain,
+        c: char,
+        id: GlyphId,
+        span: Span,
+    ) -> Self {
+        let class = EquationElem::class_in(styles)
+            .or_else(|| match c {
+                ':' => Some(MathClass::Relation),
+                '.' | '/' | '⋯' | '⋱' | '⋰' | '⋮' => Some(MathClass::Normal),
+                _ => unicode_math_class::class(c),
+            })
+            .unwrap_or(MathClass::Normal);
+
         let mut fragment = Self {
             id,
             c,
             font: ctx.font.clone(),
-            lang: TextElem::lang_in(ctx.styles()),
-            fill: TextElem::fill_in(ctx.styles()).as_decoration(),
-            shift: TextElem::baseline_in(ctx.styles()),
-            style: ctx.style,
-            font_size: ctx.size,
+            lang: TextElem::lang_in(styles),
+            fill: TextElem::fill_in(styles).as_decoration(),
+            shift: TextElem::baseline_in(styles),
+            font_size: scaled_font_size(ctx, styles),
+            math_size: EquationElem::size_in(styles),
             width: Abs::zero(),
             ascent: Abs::zero(),
             descent: Abs::zero(),
@@ -269,7 +272,7 @@ impl GlyphFragment {
             accent_attach: Abs::zero(),
             class,
             span,
-            meta: MetaElem::data_in(ctx.styles()),
+            meta: MetaElem::data_in(styles),
         };
         fragment.set_id(ctx, id);
         fragment
@@ -288,7 +291,7 @@ impl GlyphFragment {
     /// styles. This is used to replace the glyph with a stretch variant.
     pub fn set_id(&mut self, ctx: &MathContext, id: GlyphId) {
         let advance = ctx.ttf.glyph_hor_advance(id).unwrap_or_default();
-        let italics = italics_correction(ctx, id).unwrap_or_default();
+        let italics = italics_correction(ctx, id, self.font_size).unwrap_or_default();
         let bbox = ctx.ttf.glyph_bounding_box(id).unwrap_or(Rect {
             x_min: 0,
             y_min: 0,
@@ -296,8 +299,9 @@ impl GlyphFragment {
             y_max: 0,
         });
 
-        let mut width = advance.scaled(ctx);
-        let accent_attach = accent_attach(ctx, id).unwrap_or((width + italics) / 2.0);
+        let mut width = advance.scaled(ctx, self.font_size);
+        let accent_attach =
+            accent_attach(ctx, id, self.font_size).unwrap_or((width + italics) / 2.0);
 
         if !is_extended_shape(ctx, id) {
             width += italics;
@@ -305,8 +309,8 @@ impl GlyphFragment {
 
         self.id = id;
         self.width = width;
-        self.ascent = bbox.y_max.scaled(ctx);
-        self.descent = -bbox.y_min.scaled(ctx);
+        self.ascent = bbox.y_max.scaled(ctx, self.font_size);
+        self.descent = -bbox.y_min.scaled(ctx, self.font_size);
         self.italics_correction = italics;
         self.accent_attach = accent_attach;
     }
@@ -319,11 +323,11 @@ impl GlyphFragment {
         VariantFragment {
             c: self.c,
             id: Some(self.id),
-            style: self.style,
             font_size: self.font_size,
             italics_correction: self.italics_correction,
             accent_attach: self.accent_attach,
             class: self.class,
+            math_size: self.math_size,
             span: self.span,
             limits: self.limits,
             frame: self.into_frame(),
@@ -388,9 +392,9 @@ pub struct VariantFragment {
     pub italics_correction: Abs,
     pub accent_attach: Abs,
     pub frame: Frame,
-    pub style: MathStyle,
     pub font_size: Abs,
-    pub class: Option<MathClass>,
+    pub class: MathClass,
+    pub math_size: MathSize,
     pub span: Span,
     pub limits: Limits,
     pub mid_stretched: Option<bool>,
@@ -401,7 +405,8 @@ impl VariantFragment {
     /// on the axis.
     pub fn center_on_axis(&mut self, ctx: &MathContext) {
         let h = self.frame.height();
-        self.frame.set_baseline(h / 2.0 + scaled!(ctx, axis_height));
+        let axis = ctx.constants.axis_height().scaled(ctx, self.font_size);
+        self.frame.set_baseline(h / 2.0 + axis);
     }
 }
 
@@ -414,9 +419,9 @@ impl Debug for VariantFragment {
 #[derive(Debug, Clone)]
 pub struct FrameFragment {
     pub frame: Frame,
-    pub style: MathStyle,
     pub font_size: Abs,
     pub class: MathClass,
+    pub math_size: MathSize,
     pub limits: Limits,
     pub spaced: bool,
     pub base_ascent: Abs,
@@ -426,15 +431,15 @@ pub struct FrameFragment {
 }
 
 impl FrameFragment {
-    pub fn new(ctx: &MathContext, mut frame: Frame) -> Self {
+    pub fn new(ctx: &MathContext, styles: StyleChain, mut frame: Frame) -> Self {
         let base_ascent = frame.ascent();
         let accent_attach = frame.width() / 2.0;
-        frame.meta(ctx.styles(), false);
+        frame.meta(styles, false);
         Self {
             frame,
-            font_size: ctx.size,
-            style: ctx.style,
-            class: MathClass::Normal,
+            font_size: scaled_font_size(ctx, styles),
+            class: EquationElem::class_in(styles).unwrap_or(MathClass::Normal),
+            math_size: EquationElem::size_in(styles),
             limits: Limits::Never,
             spaced: false,
             base_ascent,
@@ -480,13 +485,25 @@ pub struct SpacingFragment {
 }
 
 /// Look up the italics correction for a glyph.
-fn italics_correction(ctx: &MathContext, id: GlyphId) -> Option<Abs> {
-    Some(ctx.table.glyph_info?.italic_corrections?.get(id)?.scaled(ctx))
+fn italics_correction(ctx: &MathContext, id: GlyphId, font_size: Abs) -> Option<Abs> {
+    Some(
+        ctx.table
+            .glyph_info?
+            .italic_corrections?
+            .get(id)?
+            .scaled(ctx, font_size),
+    )
 }
 
 /// Loop up the top accent attachment position for a glyph.
-fn accent_attach(ctx: &MathContext, id: GlyphId) -> Option<Abs> {
-    Some(ctx.table.glyph_info?.top_accent_attachments?.get(id)?.scaled(ctx))
+fn accent_attach(ctx: &MathContext, id: GlyphId, font_size: Abs) -> Option<Abs> {
+    Some(
+        ctx.table
+            .glyph_info?
+            .top_accent_attachments?
+            .get(id)?
+            .scaled(ctx, font_size),
+    )
 }
 
 /// Look up the script/scriptscript alternates for a glyph
@@ -515,6 +532,7 @@ fn is_extended_shape(ctx: &MathContext, id: GlyphId) -> bool {
 #[allow(unused)]
 fn kern_at_height(
     ctx: &MathContext,
+    font_size: Abs,
     id: GlyphId,
     corner: Corner,
     height: Abs,
@@ -528,9 +546,9 @@ fn kern_at_height(
     }?;
 
     let mut i = 0;
-    while i < kern.count() && height > kern.height(i)?.scaled(ctx) {
+    while i < kern.count() && height > kern.height(i)?.scaled(ctx, font_size) {
         i += 1;
     }
 
-    Some(kern.kern(i)?.scaled(ctx))
+    Some(kern.kern(i)?.scaled(ctx, font_size))
 }
diff --git a/crates/typst/src/math/lr.rs b/crates/typst/src/math/lr.rs
index 6d2bdbf1f..a34c934fb 100644
--- a/crates/typst/src/math/lr.rs
+++ b/crates/typst/src/math/lr.rs
@@ -1,7 +1,9 @@
 use unicode_math_class::MathClass;
 
 use crate::diag::SourceResult;
-use crate::foundations::{elem, func, Content, NativeElement, Packed, Resolve, Smart};
+use crate::foundations::{
+    elem, func, Content, NativeElement, Packed, Resolve, Smart, StyleChain,
+};
 use crate::layout::{Abs, Em, Length, Rel};
 use crate::math::{
     GlyphFragment, LayoutMath, MathContext, MathFragment, Scaled, SpacingFragment,
@@ -37,16 +39,16 @@ pub struct LrElem {
 
 impl LayoutMath for Packed<LrElem> {
     #[typst_macros::time(name = "math.lr", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         let mut body = self.body();
         if let Some(elem) = body.to_packed::<LrElem>() {
-            if elem.size(ctx.styles()).is_auto() {
+            if elem.size(styles).is_auto() {
                 body = elem.body();
             }
         }
 
-        let mut fragments = ctx.layout_fragments(body)?;
-        let axis = scaled!(ctx, axis_height);
+        let mut fragments = ctx.layout_fragments(body, styles)?;
+        let axis = scaled!(ctx, styles, axis_height);
         let max_extent = fragments
             .iter()
             .map(|fragment| (fragment.ascent() - axis).max(fragment.descent() + axis))
@@ -54,17 +56,17 @@ impl LayoutMath for Packed<LrElem> {
             .unwrap_or_default();
 
         let height = self
-            .size(ctx.styles())
+            .size(styles)
             .unwrap_or(Rel::one())
-            .resolve(ctx.styles())
+            .resolve(styles)
             .relative_to(2.0 * max_extent);
 
         // Scale up fragments at both ends.
         match fragments.as_mut_slice() {
-            [one] => scale(ctx, one, height, None),
+            [one] => scale(ctx, styles, one, height, None),
             [first, .., last] => {
-                scale(ctx, first, height, Some(MathClass::Opening));
-                scale(ctx, last, height, Some(MathClass::Closing));
+                scale(ctx, styles, first, height, Some(MathClass::Opening));
+                scale(ctx, styles, last, height, Some(MathClass::Closing));
             }
             _ => {}
         }
@@ -74,7 +76,7 @@ impl LayoutMath for Packed<LrElem> {
             if let MathFragment::Variant(ref mut variant) = fragment {
                 if variant.mid_stretched == Some(false) {
                     variant.mid_stretched = Some(true);
-                    scale(ctx, fragment, height, Some(MathClass::Large));
+                    scale(ctx, styles, fragment, height, Some(MathClass::Large));
                 }
             }
         }
@@ -112,8 +114,8 @@ pub struct MidElem {
 
 impl LayoutMath for Packed<MidElem> {
     #[typst_macros::time(name = "math.mid", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let mut fragments = ctx.layout_fragments(self.body())?;
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let mut fragments = ctx.layout_fragments(self.body(), styles)?;
 
         for fragment in &mut fragments {
             match fragment {
@@ -137,23 +139,24 @@ impl LayoutMath for Packed<MidElem> {
 /// Scale a math fragment to a height.
 fn scale(
     ctx: &mut MathContext,
+    styles: StyleChain,
     fragment: &mut MathFragment,
     height: Abs,
     apply: Option<MathClass>,
 ) {
     if matches!(
         fragment.class(),
-        Some(MathClass::Opening | MathClass::Closing | MathClass::Fence)
+        MathClass::Opening | MathClass::Closing | MathClass::Fence
     ) {
         let glyph = match fragment {
             MathFragment::Glyph(glyph) => glyph.clone(),
             MathFragment::Variant(variant) => {
-                GlyphFragment::new(ctx, variant.c, variant.span)
+                GlyphFragment::new(ctx, styles, variant.c, variant.span)
             }
             _ => return,
         };
 
-        let short_fall = DELIM_SHORT_FALL.scaled(ctx);
+        let short_fall = DELIM_SHORT_FALL.at(glyph.font_size);
         let mut stretched = glyph.stretch_vertical(ctx, height, short_fall);
         stretched.center_on_axis(ctx);
 
diff --git a/crates/typst/src/math/matrix.rs b/crates/typst/src/math/matrix.rs
index 24563a450..616cc7381 100644
--- a/crates/typst/src/math/matrix.rs
+++ b/crates/typst/src/math/matrix.rs
@@ -9,8 +9,8 @@ use crate::layout::{
     Abs, Axes, Em, FixedAlignment, Frame, FrameItem, Length, Point, Ratio, Rel, Size,
 };
 use crate::math::{
-    alignments, stack, AlignmentResult, FrameFragment, GlyphFragment, LayoutMath,
-    MathContext, Scaled, DELIM_SHORT_FALL,
+    alignments, scaled_font_size, stack, style_for_denominator, AlignmentResult,
+    FrameFragment, GlyphFragment, LayoutMath, MathContext, Scaled, DELIM_SHORT_FALL,
 };
 use crate::syntax::{Span, Spanned};
 use crate::text::TextElem;
@@ -59,16 +59,19 @@ pub struct VecElem {
 
 impl LayoutMath for Packed<VecElem> {
     #[typst_macros::time(name = "math.vec", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let delim = self.delim(ctx.styles());
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let delim = self.delim(styles);
         let frame = layout_vec_body(
             ctx,
+            styles,
             self.children(),
             FixedAlignment::Center,
-            self.gap(ctx.styles()),
+            self.gap(styles),
         )?;
+
         layout_delimiters(
             ctx,
+            styles,
             frame,
             delim.map(Delimiter::open),
             delim.map(Delimiter::close),
@@ -212,8 +215,8 @@ pub struct MatElem {
 
 impl LayoutMath for Packed<MatElem> {
     #[typst_macros::time(name = "math.mat", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let augment = self.augment(ctx.styles());
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let augment = self.augment(styles);
         let rows = self.rows();
 
         if let Some(aug) = &augment {
@@ -242,17 +245,19 @@ impl LayoutMath for Packed<MatElem> {
             }
         }
 
-        let delim = self.delim(ctx.styles());
+        let delim = self.delim(styles);
         let frame = layout_mat_body(
             ctx,
+            styles,
             rows,
             augment,
-            Axes::new(self.column_gap(ctx.styles()), self.row_gap(ctx.styles())),
+            Axes::new(self.column_gap(styles), self.row_gap(styles)),
             self.span(),
         )?;
 
         layout_delimiters(
             ctx,
+            styles,
             frame,
             delim.map(Delimiter::open),
             delim.map(Delimiter::close),
@@ -311,22 +316,23 @@ pub struct CasesElem {
 
 impl LayoutMath for Packed<CasesElem> {
     #[typst_macros::time(name = "math.cases", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let delim = self.delim(ctx.styles());
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let delim = self.delim(styles);
         let frame = layout_vec_body(
             ctx,
+            styles,
             self.children(),
             FixedAlignment::Start,
-            self.gap(ctx.styles()),
+            self.gap(styles),
         )?;
 
-        let (open, close) = if self.reverse(ctx.styles()) {
+        let (open, close) = if self.reverse(styles) {
             (None, Some(delim.close()))
         } else {
             (Some(delim.open()), None)
         };
 
-        layout_delimiters(ctx, frame, open, close, self.span())
+        layout_delimiters(ctx, styles, frame, open, close, self.span())
     }
 }
 
@@ -377,23 +383,26 @@ impl Delimiter {
 /// Layout the inner contents of a vector.
 fn layout_vec_body(
     ctx: &mut MathContext,
+    styles: StyleChain,
     column: &[Content],
     align: FixedAlignment,
     row_gap: Rel<Abs>,
 ) -> SourceResult<Frame> {
     let gap = row_gap.relative_to(ctx.regions.base().y);
-    ctx.style(ctx.style.for_denominator());
+
+    let denom_style = style_for_denominator(styles);
     let mut flat = vec![];
     for child in column {
-        flat.push(ctx.layout_row(child)?);
+        flat.push(ctx.layout_row(child, styles.chain(&denom_style))?);
     }
-    ctx.unstyle();
-    Ok(stack(ctx, flat, align, gap, 0))
+
+    Ok(stack(ctx, styles, flat, align, gap, 0))
 }
 
 /// Layout the inner contents of a matrix.
 fn layout_mat_body(
     ctx: &mut MathContext,
+    styles: StyleChain,
     rows: &[Vec<Content>],
     augment: Option<Augment<Abs>>,
     gap: Axes<Rel<Abs>>,
@@ -406,10 +415,11 @@ fn layout_mat_body(
     // with font size to ensure that augmentation lines
     // look correct by default at all matrix sizes.
     // The line cap is also set to square because it looks more "correct".
-    let default_stroke_thickness = DEFAULT_STROKE_THICKNESS.scaled(ctx);
+    let font_size = scaled_font_size(ctx, styles);
+    let default_stroke_thickness = DEFAULT_STROKE_THICKNESS.at(font_size);
     let default_stroke = FixedStroke {
         thickness: default_stroke_thickness,
-        paint: TextElem::fill_in(ctx.styles()).as_decoration(),
+        paint: TextElem::fill_in(styles).as_decoration(),
         cap: LineCap::Square,
         ..Default::default()
     };
@@ -443,10 +453,10 @@ fn layout_mat_body(
     // individual cells are then added to it.
     let mut cols = vec![vec![]; ncols];
 
-    ctx.style(ctx.style.for_denominator());
+    let denom_style = style_for_denominator(styles);
     for (row, (ascent, descent)) in rows.iter().zip(&mut heights) {
         for (cell, col) in row.iter().zip(&mut cols) {
-            let cell = ctx.layout_row(cell)?;
+            let cell = ctx.layout_row(cell, styles.chain(&denom_style))?;
 
             ascent.set_max(cell.ascent());
             descent.set_max(cell.descent());
@@ -454,7 +464,6 @@ fn layout_mat_body(
             col.push(cell);
         }
     }
-    ctx.unstyle();
 
     // For each row, combine maximum ascent and descent into a row height.
     // Sum the row heights, then add the total height of the gaps between rows.
@@ -472,7 +481,8 @@ fn layout_mat_body(
         let mut y = Abs::zero();
 
         for (cell, &(ascent, descent)) in col.into_iter().zip(&heights) {
-            let cell = cell.into_aligned_frame(ctx, &points, FixedAlignment::Center);
+            let cell =
+                cell.into_aligned_frame(ctx, styles, &points, FixedAlignment::Center);
             let pos = Point::new(
                 if points.is_empty() { x + (rcol - cell.width()) / 2.0 } else { x },
                 y + ascent - cell.ascent(),
@@ -542,28 +552,30 @@ fn line_item(length: Abs, vertical: bool, stroke: FixedStroke, span: Span) -> Fr
 /// Layout the outer wrapper around the body of a vector or matrix.
 fn layout_delimiters(
     ctx: &mut MathContext,
+    styles: StyleChain,
     mut frame: Frame,
     left: Option<char>,
     right: Option<char>,
     span: Span,
 ) -> SourceResult<()> {
-    let axis = scaled!(ctx, axis_height);
-    let short_fall = DELIM_SHORT_FALL.scaled(ctx);
+    let font_size = scaled_font_size(ctx, styles);
+    let short_fall = DELIM_SHORT_FALL.at(font_size);
+    let axis = ctx.constants.axis_height().scaled(ctx, font_size);
     let height = frame.height();
     let target = height + VERTICAL_PADDING.of(height);
     frame.set_baseline(height / 2.0 + axis);
 
     if let Some(left) = left {
-        let mut left =
-            GlyphFragment::new(ctx, left, span).stretch_vertical(ctx, target, short_fall);
+        let mut left = GlyphFragment::new(ctx, styles, left, span)
+            .stretch_vertical(ctx, target, short_fall);
         left.center_on_axis(ctx);
         ctx.push(left);
     }
 
-    ctx.push(FrameFragment::new(ctx, frame));
+    ctx.push(FrameFragment::new(ctx, styles, frame));
 
     if let Some(right) = right {
-        let mut right = GlyphFragment::new(ctx, right, span)
+        let mut right = GlyphFragment::new(ctx, styles, right, span)
             .stretch_vertical(ctx, target, short_fall);
         right.center_on_axis(ctx);
         ctx.push(right);
diff --git a/crates/typst/src/math/mod.rs b/crates/typst/src/math/mod.rs
index ee0a38257..3338fb639 100644
--- a/crates/typst/src/math/mod.rs
+++ b/crates/typst/src/math/mod.rs
@@ -6,7 +6,8 @@ mod accent;
 mod align;
 mod attach;
 mod cancel;
-mod class;
+#[path = "class.rs"]
+mod class_;
 mod equation;
 mod frac;
 mod fragment;
@@ -24,7 +25,7 @@ pub use self::accent::*;
 pub use self::align::*;
 pub use self::attach::*;
 pub use self::cancel::*;
-pub use self::class::*;
+pub use self::class_::*;
 pub use self::equation::*;
 pub use self::frac::*;
 pub use self::lr::*;
@@ -46,7 +47,7 @@ use crate::foundations::{
     category, Category, Content, Module, Resolve, Scope, StyleChain,
 };
 use crate::layout::{BoxElem, HElem, Spacing};
-use crate::realize::BehavedBuilder;
+use crate::realize::{realize, BehavedBuilder};
 use crate::text::{LinebreakElem, SpaceElem, TextElem};
 
 /// Typst has special [syntax]($syntax/#math) and library functions to typeset
@@ -215,12 +216,12 @@ pub fn module() -> Module {
 /// Layout for math elements.
 pub trait LayoutMath {
     /// Layout the element, producing fragment in the context.
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()>;
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()>;
 }
 
 impl LayoutMath for Content {
     #[typst_macros::time(name = "math", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         // Directly layout the body of nested equations instead of handling it
         // like a normal equation so that things like this work:
         // ```
@@ -228,11 +229,11 @@ impl LayoutMath for Content {
         // $ my r^2 $
         // ```
         if let Some(elem) = self.to_packed::<EquationElem>() {
-            return elem.layout_math(ctx);
+            return elem.layout_math(ctx, styles);
         }
 
-        if let Some(realized) = ctx.realize(self)? {
-            return realized.layout_math(ctx);
+        if let Some(realized) = realize(ctx.engine, self, styles)? {
+            return realized.layout_math(ctx, styles);
         }
 
         if self.is_sequence() {
@@ -242,32 +243,28 @@ impl LayoutMath for Content {
             });
 
             for (child, _) in bb.finish().0.iter() {
-                child.layout_math(ctx)?;
+                child.layout_math(ctx, styles)?;
             }
             return Ok(());
         }
 
-        if let Some((elem, styles)) = self.to_styled() {
-            if TextElem::font_in(ctx.styles().chain(styles))
-                != TextElem::font_in(ctx.styles())
-            {
-                let frame = ctx.layout_content(self)?;
-                ctx.push(FrameFragment::new(ctx, frame).with_spaced(true));
+        if let Some((elem, local)) = self.to_styled() {
+            let outer = styles;
+            let styles = outer.chain(local);
+
+            if TextElem::font_in(styles) != TextElem::font_in(outer) {
+                let frame = ctx.layout_content(elem, styles)?;
+                ctx.push(FrameFragment::new(ctx, styles, frame).with_spaced(true));
                 return Ok(());
             }
 
-            let prev_map = std::mem::replace(&mut ctx.local, styles.clone());
-            let prev_size = ctx.size;
-            ctx.local.apply(prev_map.clone());
-            ctx.size = TextElem::size_in(ctx.styles());
-            elem.layout_math(ctx)?;
-            ctx.size = prev_size;
-            ctx.local = prev_map;
+            elem.layout_math(ctx, styles)?;
             return Ok(());
         }
 
         if self.is::<SpaceElem>() {
-            ctx.push(MathFragment::Space(ctx.space_width.scaled(ctx)));
+            let font_size = scaled_font_size(ctx, styles);
+            ctx.push(MathFragment::Space(ctx.space_width.at(font_size)));
             return Ok(());
         }
 
@@ -280,8 +277,8 @@ impl LayoutMath for Content {
             if let Spacing::Rel(rel) = elem.amount() {
                 if rel.rel.is_zero() {
                     ctx.push(SpacingFragment {
-                        width: rel.abs.resolve(ctx.styles()),
-                        weak: elem.weak(ctx.styles()),
+                        width: rel.abs.resolve(styles),
+                        weak: elem.weak(styles),
                     });
                 }
             }
@@ -289,27 +286,27 @@ impl LayoutMath for Content {
         }
 
         if let Some(elem) = self.to_packed::<TextElem>() {
-            let fragment = ctx.layout_text(elem)?;
+            let fragment = ctx.layout_text(elem, styles)?;
             ctx.push(fragment);
             return Ok(());
         }
 
         if let Some(boxed) = self.to_packed::<BoxElem>() {
-            let frame = ctx.layout_box(boxed)?;
-            ctx.push(FrameFragment::new(ctx, frame).with_spaced(true));
+            let frame = ctx.layout_box(boxed, styles)?;
+            ctx.push(FrameFragment::new(ctx, styles, frame).with_spaced(true));
             return Ok(());
         }
 
         if let Some(elem) = self.with::<dyn LayoutMath>() {
-            return elem.layout_math(ctx);
+            return elem.layout_math(ctx, styles);
         }
 
-        let mut frame = ctx.layout_content(self)?;
+        let mut frame = ctx.layout_content(self, styles)?;
         if !frame.has_baseline() {
-            let axis = scaled!(ctx, axis_height);
+            let axis = scaled!(ctx, styles, axis_height);
             frame.set_baseline(frame.height() / 2.0 + axis);
         }
-        ctx.push(FrameFragment::new(ctx, frame).with_spaced(true));
+        ctx.push(FrameFragment::new(ctx, styles, frame).with_spaced(true));
 
         Ok(())
     }
diff --git a/crates/typst/src/math/op.rs b/crates/typst/src/math/op.rs
index 1d0645ff7..a13cec4d8 100644
--- a/crates/typst/src/math/op.rs
+++ b/crates/typst/src/math/op.rs
@@ -2,9 +2,9 @@ use ecow::EcoString;
 use unicode_math_class::MathClass;
 
 use crate::diag::SourceResult;
-use crate::foundations::{elem, Content, NativeElement, Packed, Scope};
+use crate::foundations::{elem, Content, NativeElement, Packed, Scope, StyleChain};
 use crate::layout::HElem;
-use crate::math::{FrameFragment, LayoutMath, Limits, MathContext, MathStyleElem, THIN};
+use crate::math::{upright, FrameFragment, LayoutMath, Limits, MathContext, THIN};
 use crate::text::TextElem;
 
 /// A text operator in an equation.
@@ -35,19 +35,19 @@ pub struct OpElem {
 
 impl LayoutMath for Packed<OpElem> {
     #[typst_macros::time(name = "math.op", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let fragment = ctx.layout_fragment(self.text())?;
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        let fragment = ctx.layout_fragment(self.text(), styles)?;
         let italics = fragment.italics_correction();
         let accent_attach = fragment.accent_attach();
         let text_like = fragment.is_text_like();
 
         ctx.push(
-            FrameFragment::new(ctx, fragment.into_frame())
+            FrameFragment::new(ctx, styles, fragment.into_frame())
                 .with_class(MathClass::Large)
                 .with_italics_correction(italics)
                 .with_accent_attach(accent_attach)
                 .with_text_like(text_like)
-                .with_limits(if self.limits(ctx.styles()) {
+                .with_limits(if self.limits(styles) {
                     Limits::Display
                 } else {
                     Limits::Never
@@ -72,7 +72,7 @@ macro_rules! ops {
 
             let dif = |d| {
                 HElem::new(THIN.into()).with_weak(true).pack()
-                    + MathStyleElem::new(TextElem::packed(d)).with_italic(Some(false)).pack()
+                    + upright(TextElem::packed(d))
             };
             math.define("dif", dif('d'));
             math.define("Dif", dif('D'));
diff --git a/crates/typst/src/math/root.rs b/crates/typst/src/math/root.rs
index db3a7b85a..65060de3a 100644
--- a/crates/typst/src/math/root.rs
+++ b/crates/typst/src/math/root.rs
@@ -1,8 +1,11 @@
+use comemo::Prehashed;
+
 use crate::diag::SourceResult;
-use crate::foundations::{elem, func, Content, NativeElement, Packed};
+use crate::foundations::{elem, func, Content, NativeElement, Packed, StyleChain};
 use crate::layout::{Abs, Frame, FrameItem, Point, Size};
 use crate::math::{
-    FrameFragment, GlyphFragment, LayoutMath, MathContext, MathSize, Scaled,
+    style_cramped, EquationElem, FrameFragment, GlyphFragment, LayoutMath, MathContext,
+    MathSize, Scaled,
 };
 use crate::syntax::Span;
 use crate::text::TextElem;
@@ -41,8 +44,8 @@ pub struct RootElem {
 
 impl LayoutMath for Packed<RootElem> {
     #[typst_macros::time(name = "math.root", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        layout(ctx, self.index(ctx.styles()).as_ref(), self.radicand(), self.span())
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        layout(ctx, styles, self.index(styles).as_ref(), self.radicand(), self.span())
     }
 }
 
@@ -52,36 +55,37 @@ impl LayoutMath for Packed<RootElem> {
 /// See also: https://www.w3.org/TR/mathml-core/#radicals-msqrt-mroot
 fn layout(
     ctx: &mut MathContext,
+    styles: StyleChain,
     index: Option<&Content>,
     radicand: &Content,
     span: Span,
 ) -> SourceResult<()> {
     let gap = scaled!(
-        ctx,
+        ctx, styles,
         text: radical_vertical_gap,
         display: radical_display_style_vertical_gap,
     );
-    let thickness = scaled!(ctx, radical_rule_thickness);
-    let extra_ascender = scaled!(ctx, radical_extra_ascender);
-    let kern_before = scaled!(ctx, radical_kern_before_degree);
-    let kern_after = scaled!(ctx, radical_kern_after_degree);
+    let thickness = scaled!(ctx, styles, radical_rule_thickness);
+    let extra_ascender = scaled!(ctx, styles, radical_extra_ascender);
+    let kern_before = scaled!(ctx, styles, radical_kern_before_degree);
+    let kern_after = scaled!(ctx, styles, radical_kern_after_degree);
     let raise_factor = percent!(ctx, radical_degree_bottom_raise_percent);
 
     // Layout radicand.
-    ctx.style(ctx.style.with_cramped(true));
-    let radicand = ctx.layout_frame(radicand)?;
-    ctx.unstyle();
+    let cramped = style_cramped();
+    let radicand = ctx.layout_frame(radicand, styles.chain(&cramped))?;
 
     // Layout root symbol.
     let target = radicand.height() + thickness + gap;
-    let sqrt = GlyphFragment::new(ctx, '√', span)
+    let sqrt = GlyphFragment::new(ctx, styles, '√', span)
         .stretch_vertical(ctx, target, Abs::zero())
         .frame;
 
     // Layout the index.
-    ctx.style(ctx.style.with_size(MathSize::ScriptScript));
-    let index = index.map(|elem| ctx.layout_frame(elem)).transpose()?;
-    ctx.unstyle();
+    let sscript = Prehashed::new(EquationElem::set_size(MathSize::ScriptScript));
+    let index = index
+        .map(|elem| ctx.layout_frame(elem, styles.chain(&sscript)))
+        .transpose()?;
 
     // TeXbook, page 443, item 11
     // Keep original gap, and then distribute any remaining free space
@@ -133,7 +137,7 @@ fn layout(
         FrameItem::Shape(
             Geometry::Line(Point::with_x(radicand.width())).stroked(
                 FixedStroke::from_pair(
-                    TextElem::fill_in(ctx.styles()).as_decoration(),
+                    TextElem::fill_in(styles).as_decoration(),
                     thickness,
                 ),
             ),
@@ -142,7 +146,7 @@ fn layout(
     );
 
     frame.push_frame(radicand_pos, radicand);
-    ctx.push(FrameFragment::new(ctx, frame));
+    ctx.push(FrameFragment::new(ctx, styles, frame));
 
     Ok(())
 }
diff --git a/crates/typst/src/math/row.rs b/crates/typst/src/math/row.rs
index 87ac154d5..89e1695ea 100644
--- a/crates/typst/src/math/row.rs
+++ b/crates/typst/src/math/row.rs
@@ -2,11 +2,11 @@ use std::iter::once;
 
 use unicode_math_class::MathClass;
 
-use crate::foundations::Resolve;
+use crate::foundations::{Resolve, StyleChain};
 use crate::layout::{Abs, AlignElem, Em, FixedAlignment, Frame, FrameKind, Point, Size};
 use crate::math::{
-    alignments, spacing, AlignmentResult, FrameFragment, MathContext, MathFragment,
-    MathParItem, MathSize, Scaled,
+    alignments, scaled_font_size, spacing, AlignmentResult, EquationElem, FrameFragment,
+    MathContext, MathFragment, MathParItem, MathSize,
 };
 use crate::model::ParElem;
 
@@ -61,9 +61,9 @@ impl MathRow {
 
             // Convert variable operators into binary operators if something
             // precedes them and they are not preceded by a operator or comparator.
-            if fragment.class() == Some(MathClass::Vary)
+            if fragment.class() == MathClass::Vary
                 && matches!(
-                    last.and_then(|i| resolved[i].class()),
+                    last.map(|i| resolved[i].class()),
                     Some(
                         MathClass::Normal
                             | MathClass::Alphabetic
@@ -131,8 +131,8 @@ impl MathRow {
         if self.0.len() == 1 {
             self.0
                 .first()
-                .and_then(|fragment| fragment.class())
-                .unwrap_or(MathClass::Special)
+                .map(|fragment| fragment.class())
+                .unwrap_or(MathClass::Normal)
         } else {
             // FrameFragment::new() (inside 'into_fragment' in this branch) defaults
             // to MathClass::Normal for its class.
@@ -140,23 +140,23 @@ impl MathRow {
         }
     }
 
-    pub fn into_frame(self, ctx: &MathContext) -> Frame {
-        let styles = ctx.styles();
+    pub fn into_frame(self, ctx: &MathContext, styles: StyleChain) -> Frame {
         let align = AlignElem::alignment_in(styles).resolve(styles).x;
-        self.into_aligned_frame(ctx, &[], align)
+        self.into_aligned_frame(ctx, styles, &[], align)
     }
 
-    pub fn into_fragment(self, ctx: &MathContext) -> MathFragment {
+    pub fn into_fragment(self, ctx: &MathContext, styles: StyleChain) -> MathFragment {
         if self.0.len() == 1 {
             self.0.into_iter().next().unwrap()
         } else {
-            FrameFragment::new(ctx, self.into_frame(ctx)).into()
+            FrameFragment::new(ctx, styles, self.into_frame(ctx, styles)).into()
         }
     }
 
     pub fn into_aligned_frame(
         self,
         ctx: &MathContext,
+        styles: StyleChain,
         points: &[Abs],
         align: FixedAlignment,
     ) -> Frame {
@@ -164,10 +164,11 @@ impl MathRow {
             return self.into_line_frame(points, align);
         }
 
-        let leading = if ctx.style.size >= MathSize::Text {
-            ParElem::leading_in(ctx.styles())
+        let leading = if EquationElem::size_in(styles) >= MathSize::Text {
+            ParElem::leading_in(styles)
         } else {
-            TIGHT_LEADING.scaled(ctx)
+            let font_size = scaled_font_size(ctx, styles);
+            TIGHT_LEADING.at(font_size)
         };
 
         let mut rows: Vec<_> = self.rows();
@@ -272,8 +273,7 @@ impl MathRow {
 
         let mut space_is_visible = false;
 
-        let is_relation =
-            |f: &MathFragment| matches!(f.class(), Some(MathClass::Relation));
+        let is_relation = |f: &MathFragment| matches!(f.class(), MathClass::Relation);
         let is_space = |f: &MathFragment| {
             matches!(f, MathFragment::Space(_) | MathFragment::Spacing(_))
         };
@@ -302,8 +302,8 @@ impl MathRow {
             frame.push_frame(pos, fragment.into_frame());
             empty = false;
 
-            if class == Some(MathClass::Binary)
-                || (class == Some(MathClass::Relation)
+            if class == MathClass::Binary
+                || (class == MathClass::Relation
                     && !iter.peek().map(is_relation).unwrap_or_default())
             {
                 let mut frame_prev = std::mem::replace(
diff --git a/crates/typst/src/math/spacing.rs b/crates/typst/src/math/spacing.rs
index c6c697fe6..1e8090168 100644
--- a/crates/typst/src/math/spacing.rs
+++ b/crates/typst/src/math/spacing.rs
@@ -27,15 +27,14 @@ pub(super) fn spacing(
 ) -> Option<MathFragment> {
     use MathClass::*;
 
-    let class = |f: &MathFragment| f.class().unwrap_or(Special);
     let resolve = |v: Em, size_ref: &MathFragment| -> Option<MathFragment> {
         let width = size_ref.font_size().map_or(Abs::zero(), |size| v.at(size));
         Some(SpacingFragment { width, weak: false }.into())
     };
     let script =
-        |f: &MathFragment| f.style().map_or(false, |s| s.size <= MathSize::Script);
+        |f: &MathFragment| f.math_size().map_or(false, |s| s <= MathSize::Script);
 
-    match (class(l), class(r)) {
+    match (l.class(), r.class()) {
         // No spacing before punctuation; thin spacing after punctuation, unless
         // in script size.
         (_, Punctuation) => None,
diff --git a/crates/typst/src/math/stretch.rs b/crates/typst/src/math/stretch.rs
index 90ed03b75..f05e38714 100644
--- a/crates/typst/src/math/stretch.rs
+++ b/crates/typst/src/math/stretch.rs
@@ -45,7 +45,7 @@ fn stretch_glyph(
         .table
         .variants
         .and_then(|variants| {
-            min_overlap = variants.min_connector_overlap.scaled(ctx);
+            min_overlap = variants.min_connector_overlap.scaled(ctx, base.font_size);
             if horizontal {
                 variants.horizontal_constructions
             } else {
@@ -106,12 +106,12 @@ fn assemble(
         let mut growable = Abs::zero();
 
         while let Some(part) = parts.next() {
-            let mut advance = part.full_advance.scaled(ctx);
+            let mut advance = part.full_advance.scaled(ctx, base.font_size);
             if let Some(next) = parts.peek() {
                 let max_overlap = part
                     .end_connector_length
                     .min(next.start_connector_length)
-                    .scaled(ctx);
+                    .scaled(ctx, base.font_size);
 
                 advance -= max_overlap;
                 growable += max_overlap - min_overlap;
@@ -136,10 +136,12 @@ fn assemble(
     let mut selected = vec![];
     let mut parts = parts(assembly, repeat).peekable();
     while let Some(part) = parts.next() {
-        let mut advance = part.full_advance.scaled(ctx);
+        let mut advance = part.full_advance.scaled(ctx, base.font_size);
         if let Some(next) = parts.peek() {
-            let max_overlap =
-                part.end_connector_length.min(next.start_connector_length).scaled(ctx);
+            let max_overlap = part
+                .end_connector_length
+                .min(next.start_connector_length)
+                .scaled(ctx, base.font_size);
             advance -= max_overlap;
             advance += ratio * (max_overlap - min_overlap);
         }
@@ -156,7 +158,7 @@ fn assemble(
         size = Size::new(full, height);
         baseline = base.ascent;
     } else {
-        let axis = scaled!(ctx, axis_height);
+        let axis = ctx.constants.axis_height().scaled(ctx, base.font_size);
         let width = selected.iter().map(|(f, _)| f.width).max().unwrap_or_default();
         size = Size::new(width, full);
         baseline = full / 2.0 + axis;
@@ -183,11 +185,11 @@ fn assemble(
         c: base.c,
         id: None,
         frame,
-        style: base.style,
         font_size: base.font_size,
         italics_correction: Abs::zero(),
         accent_attach,
         class: base.class,
+        math_size: base.math_size,
         span: base.span,
         limits: base.limits,
         mid_stretched: None,
diff --git a/crates/typst/src/math/style.rs b/crates/typst/src/math/style.rs
index 0d3c06fa2..595abf4ad 100644
--- a/crates/typst/src/math/style.rs
+++ b/crates/typst/src/math/style.rs
@@ -1,11 +1,9 @@
-use unicode_math_class::MathClass;
+use comemo::Prehashed;
 
-use crate::diag::SourceResult;
-use crate::foundations::{
-    elem, func, Cast, Content, NativeElement, Packed, Smart, StyleChain,
-};
-use crate::math::{LayoutMath, MathContext};
-use crate::syntax::Span;
+use crate::foundations::{func, Cast, Content, Smart, Style, StyleChain};
+use crate::layout::Abs;
+use crate::math::{EquationElem, MathContext};
+use crate::text::TextElem;
 
 /// Bold font style in math.
 ///
@@ -14,12 +12,10 @@ use crate::syntax::Span;
 /// ```
 #[func]
 pub fn bold(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body).with_bold(Some(true)).pack().spanned(span)
+    body.styled(EquationElem::set_bold(true))
 }
 
 /// Upright (non-italic) font style in math.
@@ -29,12 +25,10 @@ pub fn bold(
 /// ```
 #[func]
 pub fn upright(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body).with_italic(Some(false)).pack().spanned(span)
+    body.styled(EquationElem::set_italic(Smart::Custom(false)))
 }
 
 /// Italic font style in math.
@@ -42,27 +36,21 @@ pub fn upright(
 /// For roman letters and greek lowercase letters, this is already the default.
 #[func]
 pub fn italic(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body).with_italic(Some(true)).pack().spanned(span)
+    body.styled(EquationElem::set_italic(Smart::Custom(true)))
 }
+
 /// Serif (roman) font style in math.
 ///
 /// This is already the default.
 #[func]
 pub fn serif(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_variant(Some(MathVariant::Serif))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_variant(MathVariant::Serif))
 }
 
 /// Sans-serif font style in math.
@@ -72,15 +60,10 @@ pub fn serif(
 /// ```
 #[func(title = "Sans Serif")]
 pub fn sans(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_variant(Some(MathVariant::Sans))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_variant(MathVariant::Sans))
 }
 
 /// Calligraphic font style in math.
@@ -90,15 +73,10 @@ pub fn sans(
 /// ```
 #[func(title = "Calligraphic")]
 pub fn cal(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_variant(Some(MathVariant::Cal))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_variant(MathVariant::Cal))
 }
 
 /// Fraktur font style in math.
@@ -108,15 +86,10 @@ pub fn cal(
 /// ```
 #[func(title = "Fraktur")]
 pub fn frak(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_variant(Some(MathVariant::Frak))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_variant(MathVariant::Frak))
 }
 
 /// Monospace font style in math.
@@ -126,15 +99,10 @@ pub fn frak(
 /// ```
 #[func(title = "Monospace")]
 pub fn mono(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_variant(Some(MathVariant::Mono))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_variant(MathVariant::Mono))
 }
 
 /// Blackboard bold (double-struck) font style in math.
@@ -149,15 +117,10 @@ pub fn mono(
 /// ```
 #[func(title = "Blackboard Bold")]
 pub fn bb(
-    /// The call span of this function.
-    span: Span,
     /// The content to style.
     body: Content,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_variant(Some(MathVariant::Bb))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_variant(MathVariant::Bb))
 }
 
 /// Forced display style in math.
@@ -169,8 +132,6 @@ pub fn bb(
 /// ```
 #[func(title = "Display Size")]
 pub fn display(
-    /// The call span of this function.
-    span: Span,
     /// The content to size.
     body: Content,
     /// Whether to impose a height restriction for exponents, like regular sub-
@@ -179,11 +140,8 @@ pub fn display(
     #[default(false)]
     cramped: bool,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_size(Some(MathSize::Display))
-        .with_cramped(Some(cramped))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_size(MathSize::Display))
+        .styled(EquationElem::set_cramped(cramped))
 }
 
 /// Forced inline (text) style in math.
@@ -196,8 +154,6 @@ pub fn display(
 /// ```
 #[func(title = "Inline Size")]
 pub fn inline(
-    /// The call span of this function.
-    span: Span,
     /// The content to size.
     body: Content,
     /// Whether to impose a height restriction for exponents, like regular sub-
@@ -206,11 +162,8 @@ pub fn inline(
     #[default(false)]
     cramped: bool,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_size(Some(MathSize::Text))
-        .with_cramped(Some(cramped))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_size(MathSize::Text))
+        .styled(EquationElem::set_cramped(cramped))
 }
 
 /// Forced script style in math.
@@ -222,8 +175,6 @@ pub fn inline(
 /// ```
 #[func(title = "Script Size")]
 pub fn script(
-    /// The call span of this function.
-    span: Span,
     /// The content to size.
     body: Content,
     /// Whether to impose a height restriction for exponents, like regular sub-
@@ -232,11 +183,8 @@ pub fn script(
     #[default(true)]
     cramped: bool,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_size(Some(MathSize::Script))
-        .with_cramped(Some(cramped))
-        .pack()
-        .spanned(span)
+    body.styled(EquationElem::set_size(MathSize::Script))
+        .styled(EquationElem::set_cramped(cramped))
 }
 
 /// Forced second script style in math.
@@ -249,8 +197,6 @@ pub fn script(
 /// ```
 #[func(title = "Script-Script Size")]
 pub fn sscript(
-    /// The call span of this function.
-    span: Span,
     /// The content to size.
     body: Content,
     /// Whether to impose a height restriction for exponents, like regular sub-
@@ -259,141 +205,8 @@ pub fn sscript(
     #[default(true)]
     cramped: bool,
 ) -> Content {
-    MathStyleElem::new(body)
-        .with_size(Some(MathSize::ScriptScript))
-        .with_cramped(Some(cramped))
-        .pack()
-        .spanned(span)
-}
-
-/// A font variant in math.
-#[elem(LayoutMath)]
-pub struct MathStyleElem {
-    /// The content to style.
-    #[required]
-    pub body: Content,
-
-    /// The variant to select.
-    pub variant: Option<MathVariant>,
-
-    /// Whether to use bold glyphs.
-    pub bold: Option<bool>,
-
-    /// Whether to use italic glyphs.
-    pub italic: Option<bool>,
-
-    /// Whether to use forced size
-    pub size: Option<MathSize>,
-
-    /// Whether to limit height of exponents
-    pub cramped: Option<bool>,
-}
-
-impl LayoutMath for Packed<MathStyleElem> {
-    #[typst_macros::time(name = "math.style", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        let mut style = ctx.style;
-        if let Some(variant) = self.variant(StyleChain::default()) {
-            style = style.with_variant(variant);
-        }
-        if let Some(bold) = self.bold(StyleChain::default()) {
-            style = style.with_bold(bold);
-        }
-        if let Some(italic) = self.italic(StyleChain::default()) {
-            style = style.with_italic(italic);
-        }
-        if let Some(size) = self.size(StyleChain::default()) {
-            style = style.with_size(size);
-        }
-        if let Some(cramped) = self.cramped(StyleChain::default()) {
-            style = style.with_cramped(cramped);
-        }
-        ctx.style(style);
-        self.body().layout_math(ctx)?;
-        ctx.unstyle();
-        Ok(())
-    }
-}
-
-/// Text properties in math.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct MathStyle {
-    /// The style variant to select.
-    pub variant: MathVariant,
-    /// The size of the glyphs.
-    pub size: MathSize,
-    /// The class of the element.
-    pub class: Smart<MathClass>,
-    /// Affects the height of exponents.
-    pub cramped: bool,
-    /// Whether to use bold glyphs.
-    pub bold: bool,
-    /// Whether to use italic glyphs.
-    pub italic: Smart<bool>,
-}
-
-impl MathStyle {
-    /// This style, with the given `variant`.
-    pub fn with_variant(self, variant: MathVariant) -> Self {
-        Self { variant, ..self }
-    }
-
-    /// This style, with the given `size`.
-    pub fn with_size(self, size: MathSize) -> Self {
-        Self { size, ..self }
-    }
-
-    // This style, with the given `class`.
-    pub fn with_class(self, class: MathClass) -> Self {
-        Self { class: Smart::Custom(class), ..self }
-    }
-
-    /// This style, with `cramped` set to the given value.
-    pub fn with_cramped(self, cramped: bool) -> Self {
-        Self { cramped, ..self }
-    }
-
-    /// This style, with `bold` set to the given value.
-    pub fn with_bold(self, bold: bool) -> Self {
-        Self { bold, ..self }
-    }
-
-    /// This style, with `italic` set to the given value.
-    pub fn with_italic(self, italic: bool) -> Self {
-        Self { italic: Smart::Custom(italic), ..self }
-    }
-
-    /// The style for subscripts in the current style.
-    pub fn for_subscript(self) -> Self {
-        self.for_superscript().with_cramped(true)
-    }
-
-    /// The style for superscripts in the current style.
-    pub fn for_superscript(self) -> Self {
-        self.with_size(match self.size {
-            MathSize::Display | MathSize::Text => MathSize::Script,
-            MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
-        })
-    }
-
-    /// The style for numerators in the current style.
-    pub fn for_numerator(self) -> Self {
-        self.with_size(match self.size {
-            MathSize::Display => MathSize::Text,
-            MathSize::Text => MathSize::Script,
-            MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
-        })
-    }
-
-    /// The style for denominators in the current style.
-    pub fn for_denominator(self) -> Self {
-        self.for_numerator().with_cramped(true)
-    }
-
-    /// Apply the style to a character.
-    pub fn styled_char(self, c: char) -> char {
-        styled_char(self, c)
-    }
+    body.styled(EquationElem::set_size(MathSize::ScriptScript))
+        .styled(EquationElem::set_cramped(cramped))
 }
 
 /// The size of elements in an equation.
@@ -412,7 +225,8 @@ pub enum MathSize {
 }
 
 impl MathSize {
-    pub(super) fn factor(self, ctx: &MathContext) -> f64 {
+    /// The scaling factor.
+    pub fn factor(self, ctx: &MathContext) -> f64 {
         match self {
             Self::Display | Self::Text => 1.0,
             Self::Script => percent!(ctx, script_percent_scale_down),
@@ -422,8 +236,9 @@ impl MathSize {
 }
 
 /// A mathematical style variant, as defined by Unicode.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Cast, Hash)]
+#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Cast, Hash)]
 pub enum MathVariant {
+    #[default]
     Serif,
     Sans,
     Cal,
@@ -432,21 +247,53 @@ pub enum MathVariant {
     Bb,
 }
 
-impl Default for MathVariant {
-    fn default() -> Self {
-        Self::Serif
-    }
+/// Get the font size scaled with the `MathSize`.
+pub fn scaled_font_size(ctx: &MathContext, styles: StyleChain) -> Abs {
+    EquationElem::size_in(styles).factor(ctx) * TextElem::size_in(styles)
+}
+
+/// Styles something as cramped.
+pub fn style_cramped() -> Prehashed<Style> {
+    Prehashed::new(EquationElem::set_cramped(true))
+}
+
+/// The style for subscripts in the current style.
+pub fn style_for_subscript(styles: StyleChain) -> [Prehashed<Style>; 2] {
+    [style_for_superscript(styles), Prehashed::new(EquationElem::set_cramped(true))]
+}
+
+/// The style for superscripts in the current style.
+pub fn style_for_superscript(styles: StyleChain) -> Prehashed<Style> {
+    Prehashed::new(EquationElem::set_size(match EquationElem::size_in(styles) {
+        MathSize::Display | MathSize::Text => MathSize::Script,
+        MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
+    }))
+}
+
+/// The style for numerators in the current style.
+pub fn style_for_numerator(styles: StyleChain) -> Prehashed<Style> {
+    Prehashed::new(EquationElem::set_size(match EquationElem::size_in(styles) {
+        MathSize::Display => MathSize::Text,
+        MathSize::Text => MathSize::Script,
+        MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
+    }))
+}
+
+/// The style for denominators in the current style.
+pub fn style_for_denominator(styles: StyleChain) -> [Prehashed<Style>; 2] {
+    [style_for_numerator(styles), Prehashed::new(EquationElem::set_cramped(true))]
 }
 
 /// Select the correct styled math letter.
 ///
-/// https://www.w3.org/TR/mathml-core/#new-text-transform-mappings
-/// https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols
-pub(super) fn styled_char(style: MathStyle, c: char) -> char {
+/// <https://www.w3.org/TR/mathml-core/#new-text-transform-mappings>
+/// <https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols>
+pub fn styled_char(styles: StyleChain, c: char) -> char {
     use MathVariant::*;
 
-    let MathStyle { variant, bold, .. } = style;
-    let italic = style.italic.unwrap_or(matches!(
+    let variant = EquationElem::variant_in(styles);
+    let bold = EquationElem::bold_in(styles);
+    let italic = EquationElem::italic_in(styles).unwrap_or(matches!(
         c,
         'a'..='z' | 'ı' | 'ȷ' | 'A'..='Z' | 'α'..='ω' |
         '∂' | 'ϵ' | 'ϑ' | 'ϰ' | 'ϕ' | 'ϱ' | 'ϖ'
diff --git a/crates/typst/src/math/underover.rs b/crates/typst/src/math/underover.rs
index 84edf036a..84c9cbe12 100644
--- a/crates/typst/src/math/underover.rs
+++ b/crates/typst/src/math/underover.rs
@@ -1,11 +1,9 @@
-use unicode_math_class::MathClass;
-
 use crate::diag::SourceResult;
-use crate::foundations::{elem, Content, Packed};
+use crate::foundations::{elem, Content, Packed, StyleChain};
 use crate::layout::{Abs, Em, FixedAlignment, Frame, FrameItem, Point, Size};
 use crate::math::{
-    alignments, AlignmentResult, FrameFragment, GlyphFragment, LayoutMath, MathContext,
-    MathRow, Scaled,
+    alignments, scaled_font_size, style_cramped, style_for_subscript, AlignmentResult,
+    FrameFragment, GlyphFragment, LayoutMath, MathContext, MathRow, Scaled,
 };
 use crate::syntax::Span;
 use crate::text::TextElem;
@@ -34,8 +32,8 @@ pub struct UnderlineElem {
 
 impl LayoutMath for Packed<UnderlineElem> {
     #[typst_macros::time(name = "math.underline", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        layout_underoverline(ctx, self.body(), self.span(), LineKind::Under)
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        layout_underoverline(ctx, styles, self.body(), self.span(), LineKind::Under)
     }
 }
 
@@ -53,14 +51,15 @@ pub struct OverlineElem {
 
 impl LayoutMath for Packed<OverlineElem> {
     #[typst_macros::time(name = "math.overline", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
-        layout_underoverline(ctx, self.body(), self.span(), LineKind::Over)
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
+        layout_underoverline(ctx, styles, self.body(), self.span(), LineKind::Over)
     }
 }
 
 /// layout under- or overlined content
 fn layout_underoverline(
     ctx: &mut MathContext,
+    styles: StyleChain,
     body: &Content,
     span: Span,
     line: LineKind,
@@ -68,26 +67,25 @@ fn layout_underoverline(
     let (extra_height, content, line_pos, content_pos, baseline, bar_height);
     match line {
         LineKind::Under => {
-            let sep = scaled!(ctx, underbar_extra_descender);
-            bar_height = scaled!(ctx, underbar_rule_thickness);
-            let gap = scaled!(ctx, underbar_vertical_gap);
+            let sep = scaled!(ctx, styles, underbar_extra_descender);
+            bar_height = scaled!(ctx, styles, underbar_rule_thickness);
+            let gap = scaled!(ctx, styles, underbar_vertical_gap);
             extra_height = sep + bar_height + gap;
 
-            content = ctx.layout_fragment(body)?;
+            content = ctx.layout_fragment(body, styles)?;
 
             line_pos = Point::with_y(content.height() + gap + bar_height / 2.0);
             content_pos = Point::zero();
             baseline = content.ascent()
         }
         LineKind::Over => {
-            let sep = scaled!(ctx, overbar_extra_ascender);
-            bar_height = scaled!(ctx, overbar_rule_thickness);
-            let gap = scaled!(ctx, overbar_vertical_gap);
+            let sep = scaled!(ctx, styles, overbar_extra_ascender);
+            bar_height = scaled!(ctx, styles, overbar_rule_thickness);
+            let gap = scaled!(ctx, styles, overbar_vertical_gap);
             extra_height = sep + bar_height + gap;
 
-            ctx.style(ctx.style.with_cramped(true));
-            content = ctx.layout_fragment(body)?;
-            ctx.unstyle();
+            let cramped = style_cramped();
+            content = ctx.layout_fragment(body, styles.chain(&cramped))?;
 
             line_pos = Point::with_y(sep + bar_height / 2.0);
             content_pos = Point::with_y(extra_height);
@@ -99,7 +97,7 @@ fn layout_underoverline(
     let height = content.height() + extra_height;
     let size = Size::new(width, height);
 
-    let content_class = content.class().unwrap_or(MathClass::Normal);
+    let content_class = content.class();
     let mut frame = Frame::soft(size);
     frame.set_baseline(baseline);
     frame.push_frame(content_pos, content.into_frame());
@@ -107,7 +105,7 @@ fn layout_underoverline(
         line_pos,
         FrameItem::Shape(
             Geometry::Line(Point::with_x(width)).stroked(FixedStroke {
-                paint: TextElem::fill_in(ctx.styles()).as_decoration(),
+                paint: TextElem::fill_in(styles).as_decoration(),
                 thickness: bar_height,
                 ..FixedStroke::default()
             }),
@@ -115,7 +113,7 @@ fn layout_underoverline(
         ),
     );
 
-    ctx.push(FrameFragment::new(ctx, frame).with_class(content_class));
+    ctx.push(FrameFragment::new(ctx, styles, frame).with_class(content_class));
 
     Ok(())
 }
@@ -138,11 +136,12 @@ pub struct UnderbraceElem {
 
 impl LayoutMath for Packed<UnderbraceElem> {
     #[typst_macros::time(name = "math.underbrace", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         layout_underoverspreader(
             ctx,
+            styles,
             self.body(),
-            &self.annotation(ctx.styles()),
+            &self.annotation(styles),
             '⏟',
             BRACE_GAP,
             false,
@@ -169,11 +168,12 @@ pub struct OverbraceElem {
 
 impl LayoutMath for Packed<OverbraceElem> {
     #[typst_macros::time(name = "math.overbrace", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         layout_underoverspreader(
             ctx,
+            styles,
             self.body(),
-            &self.annotation(ctx.styles()),
+            &self.annotation(styles),
             '⏞',
             BRACE_GAP,
             true,
@@ -200,11 +200,12 @@ pub struct UnderbracketElem {
 
 impl LayoutMath for Packed<UnderbracketElem> {
     #[typst_macros::time(name = "math.underbrace", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         layout_underoverspreader(
             ctx,
+            styles,
             self.body(),
-            &self.annotation(ctx.styles()),
+            &self.annotation(styles),
             '⎵',
             BRACKET_GAP,
             false,
@@ -231,11 +232,12 @@ pub struct OverbracketElem {
 
 impl LayoutMath for Packed<OverbracketElem> {
     #[typst_macros::time(name = "math.overbracket", span = self.span())]
-    fn layout_math(&self, ctx: &mut MathContext) -> SourceResult<()> {
+    fn layout_math(&self, ctx: &mut MathContext, styles: StyleChain) -> SourceResult<()> {
         layout_underoverspreader(
             ctx,
+            styles,
             self.body(),
-            &self.annotation(ctx.styles()),
+            &self.annotation(styles),
             '⎴',
             BRACKET_GAP,
             true,
@@ -245,8 +247,10 @@ impl LayoutMath for Packed<OverbracketElem> {
 }
 
 /// Layout an over- or underbrace-like object.
+#[allow(clippy::too_many_arguments)]
 fn layout_underoverspreader(
     ctx: &mut MathContext,
+    styles: StyleChain,
     body: &Content,
     annotation: &Option<Content>,
     c: char,
@@ -254,26 +258,31 @@ fn layout_underoverspreader(
     reverse: bool,
     span: Span,
 ) -> SourceResult<()> {
-    let gap = gap.scaled(ctx);
-    let body = ctx.layout_row(body)?;
+    let font_size = scaled_font_size(ctx, styles);
+    let gap = gap.at(font_size);
+    let body = ctx.layout_row(body, styles)?;
     let body_class = body.class();
-    let body = body.into_fragment(ctx);
-    let glyph = GlyphFragment::new(ctx, c, span);
+    let body = body.into_fragment(ctx, styles);
+    let glyph = GlyphFragment::new(ctx, styles, c, span);
     let stretched = glyph.stretch_horizontal(ctx, body.width(), Abs::zero());
 
     let mut rows = vec![MathRow::new(vec![body]), stretched.into()];
-    ctx.style(if reverse {
-        ctx.style.for_subscript()
+
+    let (sup_style, sub_style);
+    let row_styles = if reverse {
+        sup_style = style_for_subscript(styles);
+        styles.chain(&sup_style)
     } else {
-        ctx.style.for_superscript()
-    });
+        sub_style = style_for_subscript(styles);
+        styles.chain(&sub_style)
+    };
+
     rows.extend(
         annotation
             .as_ref()
-            .map(|annotation| ctx.layout_row(annotation))
+            .map(|annotation| ctx.layout_row(annotation, row_styles))
             .transpose()?,
     );
-    ctx.unstyle();
 
     let mut baseline = 0;
     if reverse {
@@ -281,8 +290,8 @@ fn layout_underoverspreader(
         baseline = rows.len() - 1;
     }
 
-    let frame = stack(ctx, rows, FixedAlignment::Center, gap, baseline);
-    ctx.push(FrameFragment::new(ctx, frame).with_class(body_class));
+    let frame = stack(ctx, styles, rows, FixedAlignment::Center, gap, baseline);
+    ctx.push(FrameFragment::new(ctx, styles, frame).with_class(body_class));
 
     Ok(())
 }
@@ -293,6 +302,7 @@ fn layout_underoverspreader(
 /// row for the whole frame.
 pub(super) fn stack(
     ctx: &MathContext,
+    styles: StyleChain,
     rows: Vec<MathRow>,
     align: FixedAlignment,
     gap: Abs,
@@ -302,7 +312,7 @@ pub(super) fn stack(
     let AlignmentResult { points, width } = alignments(&rows);
     let rows: Vec<_> = rows
         .into_iter()
-        .map(|row| row.into_aligned_frame(ctx, &points, align))
+        .map(|row| row.into_aligned_frame(ctx, styles, &points, align))
         .collect();
 
     let mut y = Abs::zero();
diff --git a/tests/ref/math/class.png b/tests/ref/math/class.png
index a54dbd673fe5735eb3553c72f7b73fbd1807b6e1..a4d6e86c1a67be6b098457af2c921a4d9c20bb1f 100644
GIT binary patch
literal 7545
zcma)hcT`hNw|)WvLr+AMCIq4&z1M(1ARtvbh*T*`6A+|#0)kSdcMy@@dxy}acML@$
zNUzeH{Cw~4{_(x<_uaehti5KPGwYmLd-i_zo@e%isjDfF5z`U_001(@Cvutq01yNK
z;1`4c3;@Ea61@R{`_hVXGTQFg?fI83+Edu}gBCTUKOHib*+{y9U9Uq~14tm_*%rc}
z`bZN5f`aaVbv}bNnT?pCpTWR81lr8ZJGTkYFh2AsrOoYef&Q!S-75UHX%FD@KRpw_
zt)2Vz6(1g4O{b;#WJn4qeSDz!m+XqDB*4Id|D&vjlz&bbq4i)z7n-x6z~b_+wUn%q
z@0hh)y|G;+pMZb9muX208aQI;tmTo+yvL-Xy18&^Uql1ZM7WH6d3V9jgV7cuq#YE*
z$AnfA@qS-cGe#$75L^fg1CenvrdewO(xanZl8e}rH)-KN1OirtRQ!2OcJSGo3Fr;|
z%I?DLdHCoxFPU28yeMIyJBq<tHmq)jJnw246w7tE_<)%F!uCss1B7q`^Y%VaeCDel
z5Tl3EJS(u$x%y!UebG`@zLA}i1PBmobx><L-(G)P&s<*e!LL^<2`^xq6BgSHjy9XN
zJgmECkpYvXl7WE!Chp~xC&grZl9-ayua8+1@qaEt(OR1vGWtJ~O_|ZQscJD#TaQP|
zz#>F}Z~K(JSkELCGuS5?JnDNzonc2_5@E%aLry!@v_#+O?hW~u_ny&nJ`SkAyW&Jb
zUZ^er6FgK54(g$(pDto3Hw;b&Fg3aBnXXEWJC&U9W~HuiQNp@tCj51|&Pfx$at0&1
zulRs?R92n+%(3h5Tiis<%KDK>hO3|0Aa`4n_S5}ht&5Q5Zx?caC&Fzm%dzaNyaae&
zJ-#VE_80e7jylEOU~f)RwtfK~9{zome-`b?wkyHi-IYw9ef+>MWgcq>){~4{9(Nik
zVv$Wcz2o6&lhF^^9AbLvyqQdb``l}}ot|{nlhLOPFgy{pW=A`fl-K>l!NUg^VjP5q
zRlw8iwiPwsok_O!OiXR<sfxlNt;ek&N_vF+;~7LM-p*V;r(`-i?a-~~V^}{F6gxf;
zp+GA28_iyH&EiX3v54)kC%>RYA5&G8*I?>NStIPjVk_cxoLa0Q*eJ}R;xcHXB;v!?
zw7G+}R~4*_N=#l&t10*haWQLnW4C>u<Mzwj=-{VI>laKU$qFSaCtb)`m|zkrV93Ul
z91V^lxid=;1=fP8ctb^6M91!cg>-RWbc6=|A-WPkk%xCE1b`T6llfJIx*xiF9N{<@
zIc|-G+p#AqzD^9fZ}hNk@J(v9!ul0qq*@DZoiuWBy%>Q}E$dur?KBn<QqccJ?T0m2
z7F2L|W%t8QzC4x>6&yauOBZ0Skx!aOOSvB9D7O7Di0wCkPa3R>zuC$2?W(b?agjeO
zShqL4$Z{7iUEscm?E%X+;tVeD^*^s;x?r}5TX?Vh>>+DRU5TYYHEK5DbUw0h)bfyf
zbqf213whd6FRWK{eW3pnY)CtAq=!aylP?+c7S7;Meum=e+mT<u1GYa5Tnob5Ka4CH
z4E;=D7EDLmN)<_(a!ruWun0|2GGRqO*m6XGL`|DN*uIQ-#RdH$!t#`)2q4>17L(UA
zQ6raMl_aslMYiT`6<gQ+)<sVA$J-!@X9mUdCVqF%T{^cyL%?wHn5WjMfxfKY#mQzU
zIy8OZ6q7x_?(RTZIpcfq<8?QccOYsGKY?=>Mc$Jpt$Y8-Jf?(bExP6N4<Ej}7pgNE
zT4Sx9S^S)mQxQTfnxPPJ;or)BsW#H;gtfG8oN{1_rz<?RzD4y%-&Fa5NoS5s$ow+~
z3HLfbCWjb#(5U-uz@E+|15@Shz;_&W<vn28=I#r0*OR{YeattUc>=i82lV!SyWiA*
z&pICi?&eno-(}j5r-@KINipCGNMkPY4bN#ATAh(xZOgiFTY6=Z+PIZAlz%SK&R<hj
z&NR<<K?LB?LzXBhQid<DxQtTEzHYnh;4LfX6{1`7Jt=7sBvV-A!7J8H1wLk@HPMF@
z2idX!MyHf&N9ej3I>#PzG(<#(?AG+pu6fqTkrxXipkBH;V(sj35G;FjX&Vy&F)TIX
zujO>afOGvhrE{}a^af*fDl66|NMU`m_|k7W-*g1y1+3rQ5$Ln7=)F(Ot!e+jVS`a>
z^HM-e=QV(L#1~~*?EqE9NiTg=cqI0=?ACU!zb^HRDTQdFXp_NBmFTY$Fz+;i2sXK_
zY1V|0Yrg%qZc=)-(tlplO8%pk=M7hN5pl(W)8<9j*Box#r0X*OzGfSyQ7vi1N4)$e
z$M#;j;%k#a-xZfZ{gdSZORjrYzMUF_`(I;U2RcvtL-&;%D1)hRCrKTtoXhw<EVxJ3
z$fs|-{Nzks9ow_OZ<;pr?1zmEtGG$2$KmuP2}7N1<@q`r^@@z>{qA~YR`i$qY+0=Z
z`)xB7)=WrIZEGdL^LU?>o0fI9cycOc(CwgJqcxu0i~1$GWZ{86qkrUY$k|Q`Y`^PX
zpkuLiAuN28=Z3P9-IoX4RQQY_d&Io~#p0298@+TP+L&smiPk;r-{{4D{hkKaYc7qM
z<1$YcgRa(gjH$sfY2c@2onv!9`S6i<xzjmg!gE3v!e;(J>$(3;WOl!(P%UHRZAl-m
zNE^x=5eyI2bj)@AnvtVLNhO_v2~A5C&1u>+IH6Y@--!0dWL<ovlVGU|Ey!bjiiYWl
zJ;B$AZnm4cc8#3Z?V`&m!{GZZ6F4-MAX3xYw?`vo#yjgkc0FAEkigU|rm3QTrM8t@
z^u6GTOf{dJEqcuhpGVN*O!bYe6dnCTPx^OZi+X?3%%z}8;Q~hiqM_TvsH@;!pqSx>
zZMD4V`|n%dGj{~}-_Jj`32@fCy7FY?U#M*8u=(aDswJTTS=?bms87zafu-W=z?dvt
zB~z;LMJUX!0RH^YC7lIa_g<a^sjhYYnV7PcIMCZl@t+3&ou~=Qo{*CG@iTo%PhpWr
zLi`D&lsc0b<4F~3CUg(OnjR9dSWABPS&yaGm`7^&c(`Z~4bi{8I~M_zCV|sFfBThw
z`O_NTA<Vm^HH5^5%W=cY&PXT$&$wzRXkVL(!%qEP`xxO{hSI`=FEXLJIsP&=jy4uL
zra1;LY0>F6l<Ho9drp(BB%>{IY1WX)eA)dXXc|A@g{wJ7mQ>eWFNz7+XFU^TyIWDR
znZ@r`d&B_3f*5SAa-#=CbOYfccQwc`;s5lSb2eoxZ(xPfBQC+?-{}zsKW?GWvw_ru
zwYuyNEzprCM#f>8!A0Ss*U*!5GT+m6UE;wq-7LS;7EgGw-#V#@=i4vsh4EKmj+xZy
zP&Lm|e>tId^TkjnK$qEGngOuire+wtqx7KDZL@9Vj$xj4vf5>F1!HqUSc#B4=T)hd
zO?dRHBf>?F_=pybEttm`<>O<Kn2C0A>2ho#A4Y}>B=J2AWcSS3gkER|-(|lcn-5dA
zNf&yU^3o?BZ&Q%4)I(L?9KFph^ZA6gbrF$>mof(wuU4F*3D|daxRsWAmWfNgqdwg}
zgCHG|wgo*Q9Cy?zlu#Ow_!}Sk%i9e3nb=822Tyb{Wse~x487NGWVRVf1ksJ?Fw#=i
zR|)0y<Eb4ECtS*%UJr@p=P_LgK7O_f8J?WqI{Ikr-BqsFo4bj2%<Bg$W6as7sXBBz
z%-VgA2gxojH_)Sv83f+8IKqz7XxsLq7Zv68^(aQPLpW?{3^<GU^}D4}q^gC!{aLnr
zB#`SlP;1iC2jc0qh*p+=;tOv2h3fm2L0Ekt!-#Htil0fF$aU%?CRb2~OVDGDfNY-Q
z`7l`O9$o)7Z!T2p)QnoDWeT^$L$sJw)VAC_w>Z9U$RULv0r`kk^R_+N&Fk51z3Cng
zNSH|BM6rVE)A0J;7%aY}`H*|~fBX-a2yEhHJxSx0#ANUG@HWtM=Z_GWr90_B2&a2U
z!Mb(}l1YI%c5jLnZoZ22W8u}m^@O8wGfbcNLhC9{l?za_O?HAl&YcsNZxvo?cj6@^
zroN;sl{epuo*~`#u^J3&$2P+C$Njr|*h1Ck`Zu`6$O?hp7W0$zKv)&h2iA8;UOGht
zAfyXpkv^MBB0l>~H?vD!<d2Oq#Y69Ga%5dmyB_xXYAGz0r<5QtDGiSD*I>kC?X1~s
zqX0ksb88eP+wE9;0m|-`Yi=(VFIjf6o#_pJp4|i4K35$v(B`0BfSv^75mmh_U1>6#
zt4L&UfqE4j;yrHWJ_IGR{x4^UJArZk|FH3(K{a9M*Y-cQ{C|DT;=<I^E?y1=Iri|h
z7l_36TW9pzAHt4ko2Ls_nN}wEtOtXZ?tQ$`n8F1@a)mb{$|v2<ev#pJp}KU8M?RJr
zwczOvGA)l@=j=o4-a2&~!C|m(kLIJphEg!2hkS=Ce4ZvdSW}5W9Im}ZBDh<`hJ4YW
z+uk+)O$~goX*`q;`7|Y;rNp5MMMlK8I~zG7VHC*FMq<96C#p~@>b8yrW|I0HG_Mj{
zE;1dmSOgm6YaP2|RuMy<8j<;Q<P8#5ZhWYo26^mFSbSsihjZn%Fozbu{HzLgbNe8n
z%b$8`n?6Go5IyYB5<ly^|E^xv)H-UhRd4Jrkl$Zr9v+=;`N{GyIsvFAL@e}E0=H|h
zR{K>Q#iIO=6hxstty*N)m!Nw&7*yV-NRlVs8#D0^^>Hw0bZvn*4;vgk!4YA>^YNF%
zR%G;f9yo9EWbjS|v~qFdXu7)L`}IL}RBt`0K}5y1$^C3Dq(Pprt`)7!Fu0ddqwsmN
z05a-Rwz^qzDL4RSZdT;<l_tAYQz_z&d_FJe)pijZ=4~c-dlK>PDKlLAk$QH?7jS9>
zWGOl0FE5DT!fA8ZFxt!X^CxFXk66*txpBnKNcTE%-fq!+HViSGOqVY22JxLJpvLGr
zY8hSrnZaUm^Zgg_*yA?G^=EMV6^GqvqL)g!hgO}>8=3d*N6ZAOLdd}#_wnXDFIwNu
zR1a8b4O8~a*y6OWTfWFWA#>ghRY|aDX8Ah=9dB|oE}ua>AFm{vvY>}_7@angU)dcO
zMkPZoxI&#arI=<5uUL|NWQE7iFd*<Wbsd-^qQ0t5P@%ka!bYv_^rcw3>lKBRDEx?H
zPpWARVF1^^l!zS$9*0bX*jeXpBJBHgOWuaj^|*<{K}9(y4rl~~K|_hn?-nu+iZ{(1
zKnu6fxnV8G)*CO0Sm@C?ISwZk^I;rpm`BUF$w7Z0q^)-glhy05(_<9@tu5M-{t2ab
zf)(p1#f$GszuF>c)@D*PN5^img0)g#Q@Fw)!tA_+y<^ccFpN3hpUH*v`@(j+$p;s-
zM#aq>76#{zg>H_pH5#&3`oe_8*)WjsWm_%qoF1M;WagTykan@gq{XcNBCUxz_90Cf
z(cd8@;oi2pXzPit2R^<LCO|3)M`8v%#p`I;BZLVs(dzVEKAk@%f8gW_?Y~G<mwzKN
z6J7GI9<MK8LS95wPy~*i_9GBw>mj^54NFXW)$Ni<Z%0R!VU764-*edE84@#<npBH8
z??p+Zigm8iyKj-7v`sjgB+E9?j<fps-*Q<S71j&mG^1uCb!qf)q1XaS<kpWc$m{J6
z<L|dm*)<1GDyIU}Wfulqk2WdWX^%_f!PB>Q0z6P!yUXe7ovueCGSZB2H8@(-oPRW%
z#-sryYOGYCnO&PR{sH!_2|>%GZpEF(^El&meH(()klI|zrW*8^(^sAYt+>MlZOOcV
zx%6L`QYN?!&l>qM8Zbd5j)JPcEATA)LT5!C<v-IT3<cFS$nXwGFm(jxz%3=x=S+vQ
zl@hwek~#a`RsT+dI#lzdE+6$6f<;P26N&ac5O2G*!M&OJKeU4t0V+IZd{mf|(sTM6
zPnrq1h38WdlE9zsA?Pb8dA=mw%)=BQPJ2k~*5%~&tS|OJD=!2mom3#cH~;Lq@HaSb
zfEz8;6S-sLTx&XoyoKB<)XV<;=o*UEuEJ=JxX)Q%7J2<-{xd0%wk=B%qhU_JuY`YT
zEuwcSo)P4zA1tFAR*Hpl@}1!S?7^zd{eIq(+xJ&F1J6u8>jX?0-sFfmW4A`?!CEtX
zNTwrsuQg1gPla}%(_WvE{!U)kv!wuZa8LAy@?6?99x?nK=*O*+Rxwwl80FT~U!{~E
zZ)(;oa!yAX0}umv@H5}d_^Z3hb$5r(${G@ecFII+zI<R?Bf3YY>$HiR;@6Jp|M;)z
z|8LKCGXC$|h8R+M=G+!9b$9$e?$PdMaU6RC`2y5?9=@%Aj>5yj;~b-+L9arhn{9Ey
zgT=Ry<%^@FIG2d1Pgfaf>VUv*wp*ApJyt=YX(Fc0>{GL-3SmF=L!Gpgkd_%FQ=xvS
zJott!7MMxLH;ZsPF}^9kZV63I(HR;iWEywBPi;u)MKmJPn3%WYF!A8m5b@~1nGqd&
zB*MPk{F<a5VK}#@%~@*|_nT_HDDqWMd0%LVa!+0|$1l_@cCLVGmiE~$>1YpJkq*rm
z?#w$FdL_Qz>JZbk3haM;Jx17pJx|Z)`=A_rtkUcN+FBy0xQBgwuZ#jO*@P?fM;&UW
z!2wik0y^Uw8Tb8mRsA0++rN~1eC3e;UHW5;iGF$O-`L&1e0t`GeA34?)(md>sx!Rd
zG{Kx!n*K0Rw(RFGDW*>bgr&LM{4~fif|ZS`)_FaJgrU%fZJ5N7`aVYGXHrrtd+!}r
zad(!=O-2%cYkegPGworKH?M{H7~D#1t-4}NGV8R*t|~|bBrb1^pcjL9<gQOxn>@M?
zXFn9B5h%>1ExX5i&N%61vi7yfOm*nU_*{sfL@(8uc_(M_oWm)~PsdWFV;7|J5B#>j
z-8`Lq3+O!<Su`3;u%J^@-sy8?uoZ4Be*-Dyu?wy_AR)9?Onmat7P@K2GCc56u$T8$
zB9$SkpO~yT{0WhxK4BxZHP~rJjm53!o|w7In_HPL4<EmCYw}rb&OEznUw-QT`^@uM
zeFDLj#!Exl&+PpLV_-29;MVR9{vs9CBZgPE&R3}^3?URwWUd<=+6^dznCXS!TIRF+
zpess|uDCo0XUfrZfO-<aEDA6Gka6z%gK9m~c-O%Km(Zs~$I_7jNg^wI)Vi|pSAgBZ
zlTm%A`O`=5U3t4%h}G9T&T@CT!q~&)C*CwJ@^d|y2VRS$)BMm<Mb#&@$xH&n7ja09
z^T{+a_@iA{$jVcG(obI#<H*hVcqpy;f5s?!SByYcM^z*CYtNo*K~2{awEZQ|4TUNU
z_XwBViM48nH)M>GUj_MUsD4%|Ad+`sq~vd1cUr1(7rYzb?S#j@m5!eLzzHy}xP7E`
zMWZg_$5(E0MA=`j9^#PO1}?ZwCH*3Dm3j6p2ToSt{V$#XW2Yj<{e{QqAE&u%S#(0&
z1%N&QJi)el%LR`>?l8kF$Hy?YSyFC)JX~N09ecn8Pf~2%dClzrm2`8=sI0%%`tM+F
zD1wOot29of31IQ*i)<w@M4~uN_<Tbjsa~c{n51jg{rp$W3dr4++fjY?zCzDLb2v4z
z5G4-nUc*io>@b}wT@y#JuR;dwRJ`2WBsZwia2D$!tQlv`m|A&_cUKT!$hJ4ed;k~v
z=(rR_7zge?Y_F4u++iJ2Dp9AV2w&U9r`658<+pfif+}G0S&v#^>ysPjN+Z8LRJ*{4
zayuonDWcG|SoCzvYGN^>?PE1by#r4)w`bOh#@fp=);&%eQWUkmwpUNH^J_g}!E>fH
znWbWVJP96~cJ8}RpQFXuf{Mgvq>`Vl;^*ss_~hy5fB)@JLQefjbw_$`d!>kf$9I4M
z*D+~a_3iiVS;syiWVty2Q7cA*S6jCvxcD6_9k9%O)_Lj&`jlg1iFnE%Lhpn_tlhs+
zq?n{$9`TPUauM#bH4TG1Ij|d}o@k@gu<=@*rSzTVR<Nw?Mf8wCl<DRJrHr_Q3e~&X
z^uA9$*ASS9hnue_!|X~FL{XE!i)towzGNTFj!50!9mjDrS~27&)4gWF-0aNnJe{(n
z?>(prvK?R^Fc5j2l&eDPtff(jtG28hPk@Er=?=L40tk#}+1R#<6BPawLY_yI-4*nn
z%<)yJki(KcQ|&03Oa23Vxd8mzforQ1K^g8DHMP1sm%cYdWjm)Wtux0<xA4F)f51Px
zw)=4AKg}1>vj7A^r2pKX{9AX{`+OZJv$ZKR`t(o&_Nvz=3Wbg|2cjgszQT}BhSE5h
zja8|4)1xfU6xNduID!tA7wBVBJd8emuB~CTQ>GJsKMGUSyrjH$Jai{>r>T>JZJd?E
zg0_RvkPYSM+AA2yAXUO~+VHFS3$*o#Se(%5VUz`}jHErS?ZH7lX5jXJQu|-WW@XmZ
zl!lM)SiYv^59fvWDULxcr3mAx<@@YE>V}-n)g95wzxsHjFCKL8DTf%X`Lay#1$BqX
zL`i*K?ih6^_&5?%L?QoV&X4!c-?c)xy4*ePOYDitdZJ5bFLn@1`j^chqa{Z>4U8Gp
z5lcqpCP8Y;;D-}e;vydN!pJMaf^~v(6}a6j+ukRm8nQ1?U*k6qIE3L-4zx0GGV@je
z*=?e2qJJ9yiWTx+i@&ta!m{p}d>`BCPX(3;Ng8u%+|k^)vBF_jp?D{lyDm;Vq9eat
z4&s@9`Jl`aT}rMaI;>oFI)|#4{E6anCEZLE{DvC+aTJ%*b+nD1OMtrg>Nn1JZ?yln
z+WMAO#?Km@(3n@5t1aeq*;~emf-Td+$Zy&O&L8K5F&)909aj~|39!hj;9kV@%F8rs
zP(u;VI{JfTfaHGw!@mHegBwE)rcEXbtlk8H3!{<%GUpsUT+H-rM31~((`C@tb9kPs
zF+P8=@v9H`OyL!&vjFwX)aJ<5%ph~P+Nt747tz(Cp%FTidffxXsq7r~4D%~Ip)D;o
zp$TD(>dPF#ttQ_IaK<IiMt&8~ADAeK>~e;B@0HtwBBB&u8z;CM<Nr?zo*}@L3NoW|
zeS5G+FDbyAX&yjOI+1;KXmpEU7UX5547#++ZH?G(r}B8DgD$aGMHJGzk+mi+O&w-w
zzOwsYQR3((xw8tD*Im==YBr-c`$^7L*e;Be9ToBjOtpu5pU16uwtIC8A{PwVe7{Y-
zm;nFg@}Qy8uoh8;KY4rtN_hCsK>BToK2Y5<5!bB}JMp(fAHO`lmhJa+4=_V(?J37c
z67E<Fg^!AGw+Ky*n1+YqT&PpDACT3P!Re*)+21KEZSsfjuY0#hG@yi@KkRq=HCkd8
z1P->H5!7o*iDp#{8c;?g^6<CvmG;L8w_4L>4}9Yc_O+$Mok_Y)?rb{<MvUH*DD9%z
zHTnY8PETD(Nt+tbNjd%ZaQ`n4pGh%6pnuwR_iq3k`0TlmA3*o7J5@!Lnp`Q;H1Pic
Dw^F*^

literal 7599
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

diff --git a/tests/ref/math/equation-show.png b/tests/ref/math/equation-show.png
new file mode 100644
index 0000000000000000000000000000000000000000..79a70dc026e787c293f9609470e46c0f5a3239d8
GIT binary patch
literal 2428
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

literal 0
HcmV?d00001

diff --git a/tests/typ/math/equation-show.typ b/tests/typ/math/equation-show.typ
new file mode 100644
index 000000000..9334c54e4
--- /dev/null
+++ b/tests/typ/math/equation-show.typ
@@ -0,0 +1,7 @@
+// Test show rules on equations.
+
+---
+This is small: $sum_(i=0)^n$
+
+#show math.equation: math.display
+This is big: $sum_(i=0)^n$