summaryrefslogtreecommitdiff
path: root/crates/typst-layout/src/math
diff options
context:
space:
mode:
Diffstat (limited to 'crates/typst-layout/src/math')
-rw-r--r--crates/typst-layout/src/math/accent.rs75
-rw-r--r--crates/typst-layout/src/math/attach.rs515
-rw-r--r--crates/typst-layout/src/math/cancel.rs144
-rw-r--r--crates/typst-layout/src/math/frac.rs136
-rw-r--r--crates/typst-layout/src/math/fragment.rs704
-rw-r--r--crates/typst-layout/src/math/lr.rs135
-rw-r--r--crates/typst-layout/src/math/mat.rs333
-rw-r--r--crates/typst-layout/src/math/mod.rs703
-rw-r--r--crates/typst-layout/src/math/root.rs126
-rw-r--r--crates/typst-layout/src/math/run.rs469
-rw-r--r--crates/typst-layout/src/math/shared.rs207
-rw-r--r--crates/typst-layout/src/math/stretch.rs291
-rw-r--r--crates/typst-layout/src/math/text.rs344
-rw-r--r--crates/typst-layout/src/math/underover.rs327
14 files changed, 4509 insertions, 0 deletions
diff --git a/crates/typst-layout/src/math/accent.rs b/crates/typst-layout/src/math/accent.rs
new file mode 100644
index 00000000..9fa7a5a0
--- /dev/null
+++ b/crates/typst-layout/src/math/accent.rs
@@ -0,0 +1,75 @@
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Packed, StyleChain};
+use typst_library::layout::{Em, Frame, Point, Rel, Size};
+use typst_library::math::{Accent, AccentElem};
+
+use super::{
+ scaled_font_size, style_cramped, FrameFragment, GlyphFragment, MathContext,
+ MathFragment,
+};
+
+/// How much the accent can be shorter than the base.
+const ACCENT_SHORT_FALL: Em = Em::new(0.5);
+
+/// Lays out an [`AccentElem`].
+#[typst_macros::time(name = "math.accent", span = elem.span())]
+pub fn layout_accent(
+ elem: &Packed<AccentElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let cramped = style_cramped();
+ let base = ctx.layout_into_fragment(elem.base(), styles.chain(&cramped))?;
+
+ // Preserve class to preserve automatic spacing.
+ let base_class = base.class();
+ let base_attach = base.accent_attach();
+
+ let width = elem
+ .size(styles)
+ .unwrap_or(Rel::one())
+ .at(scaled_font_size(ctx, 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) = elem.accent();
+ let glyph = GlyphFragment::new(ctx, styles, *c, elem.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;
+
+ // Descent is negative because the accent's ink bottom is above the
+ // 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, 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);
+ let base_pos = Point::with_y(accent.height() + gap);
+ let baseline = base_pos.y + base.ascent();
+ let base_italics_correction = base.italics_correction();
+ let base_text_like = base.is_text_like();
+
+ let base_ascent = match &base {
+ MathFragment::Frame(frame) => frame.base_ascent,
+ _ => base.ascent(),
+ };
+
+ let mut frame = Frame::soft(size);
+ frame.set_baseline(baseline);
+ frame.push_frame(accent_pos, accent);
+ frame.push_frame(base_pos, base.into_frame());
+ ctx.push(
+ FrameFragment::new(ctx, styles, frame)
+ .with_class(base_class)
+ .with_base_ascent(base_ascent)
+ .with_italics_correction(base_italics_correction)
+ .with_accent_attach(base_attach)
+ .with_text_like(base_text_like),
+ );
+
+ Ok(())
+}
diff --git a/crates/typst-layout/src/math/attach.rs b/crates/typst-layout/src/math/attach.rs
new file mode 100644
index 00000000..0f9090f7
--- /dev/null
+++ b/crates/typst-layout/src/math/attach.rs
@@ -0,0 +1,515 @@
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Packed, Smart, StyleChain};
+use typst_library::layout::{Abs, Axis, Corner, Frame, Length, Point, Rel, Size};
+use typst_library::math::{
+ AttachElem, EquationElem, LimitsElem, PrimesElem, ScriptsElem, StretchElem,
+};
+use typst_library::text::TextElem;
+use typst_utils::OptionExt;
+
+use super::{
+ stretch_fragment, style_for_subscript, style_for_superscript, FrameFragment, Limits,
+ MathContext, MathFragment,
+};
+
+macro_rules! measure {
+ ($e: ident, $attr: ident) => {
+ $e.as_ref().map(|e| e.$attr()).unwrap_or_default()
+ };
+}
+
+/// Lays out an [`AttachElem`].
+#[typst_macros::time(name = "math.attach", span = elem.span())]
+pub fn layout_attach(
+ elem: &Packed<AttachElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let merged = elem.merge_base();
+ let elem = merged.as_ref().unwrap_or(elem);
+ let stretch = stretch_size(styles, elem);
+
+ let mut base = ctx.layout_into_fragment(elem.base(), styles)?;
+ let sup_style = style_for_superscript(styles);
+ let sup_style_chain = styles.chain(&sup_style);
+ let tl = elem.tl(sup_style_chain);
+ let tr = elem.tr(sup_style_chain);
+ let primed = tr.as_ref().is_some_and(|content| content.is::<PrimesElem>());
+ let t = elem.t(sup_style_chain);
+
+ let sub_style = style_for_subscript(styles);
+ let sub_style_chain = styles.chain(&sub_style);
+ let bl = elem.bl(sub_style_chain);
+ let br = elem.br(sub_style_chain);
+ let b = elem.b(sub_style_chain);
+
+ let limits = base.limits().active(styles);
+ let (t, tr) = match (t, tr) {
+ (Some(t), Some(tr)) if primed && !limits => (None, Some(tr + t)),
+ (Some(t), None) if !limits => (None, Some(t)),
+ (t, tr) => (t, tr),
+ };
+ let (b, br) = if limits || br.is_some() { (b, br) } else { (None, b) };
+
+ macro_rules! layout {
+ ($content:ident, $style_chain:ident) => {
+ $content
+ .map(|elem| ctx.layout_into_fragment(&elem, $style_chain))
+ .transpose()
+ };
+ }
+
+ // Layout the top and bottom attachments early so we can measure their
+ // widths, in order to calculate what the stretch size is relative to.
+ let t = layout!(t, sup_style_chain)?;
+ let b = layout!(b, sub_style_chain)?;
+ if let Some(stretch) = stretch {
+ let relative_to_width = measure!(t, width).max(measure!(b, width));
+ stretch_fragment(
+ ctx,
+ styles,
+ &mut base,
+ Some(Axis::X),
+ Some(relative_to_width),
+ stretch,
+ Abs::zero(),
+ );
+ }
+
+ let fragments = [
+ layout!(tl, sup_style_chain)?,
+ t,
+ layout!(tr, sup_style_chain)?,
+ layout!(bl, sub_style_chain)?,
+ b,
+ layout!(br, sub_style_chain)?,
+ ];
+
+ layout_attachments(ctx, styles, base, fragments)
+}
+
+/// Lays out a [`PrimeElem`].
+#[typst_macros::time(name = "math.primes", span = elem.span())]
+pub fn layout_primes(
+ elem: &Packed<PrimesElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ match *elem.count() {
+ count @ 1..=4 => {
+ let c = match count {
+ 1 => '′',
+ 2 => '″',
+ 3 => '‴',
+ 4 => '⁗',
+ _ => unreachable!(),
+ };
+ let f = ctx.layout_into_fragment(&TextElem::packed(c), styles)?;
+ ctx.push(f);
+ }
+ count => {
+ // Custom amount of primes
+ let prime =
+ ctx.layout_into_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());
+
+ for i in 0..count {
+ frame.push_frame(
+ Point::new(prime.width() * (i as f64 / 2.0), Abs::zero()),
+ prime.clone(),
+ )
+ }
+ ctx.push(FrameFragment::new(ctx, styles, frame).with_text_like(true));
+ }
+ }
+ Ok(())
+}
+
+/// Lays out a [`ScriptsElem`].
+#[typst_macros::time(name = "math.scripts", span = elem.span())]
+pub fn layout_scripts(
+ elem: &Packed<ScriptsElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let mut fragment = ctx.layout_into_fragment(elem.body(), styles)?;
+ fragment.set_limits(Limits::Never);
+ ctx.push(fragment);
+ Ok(())
+}
+
+/// Lays out a [`LimitsElem`].
+#[typst_macros::time(name = "math.limits", span = elem.span())]
+pub fn layout_limits(
+ elem: &Packed<LimitsElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let limits = if elem.inline(styles) { Limits::Always } else { Limits::Display };
+ let mut fragment = ctx.layout_into_fragment(elem.body(), styles)?;
+ fragment.set_limits(limits);
+ ctx.push(fragment);
+ Ok(())
+}
+
+/// Get the size to stretch the base to, if the attach argument is true.
+fn stretch_size(
+ styles: StyleChain,
+ elem: &Packed<AttachElem>,
+) -> Option<Smart<Rel<Length>>> {
+ // Extract from an EquationElem.
+ let mut base = elem.base();
+ if let Some(equation) = base.to_packed::<EquationElem>() {
+ base = equation.body();
+ }
+
+ base.to_packed::<StretchElem>().map(|stretch| stretch.size(styles))
+}
+
+/// Lay out the attachments.
+fn layout_attachments(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ base: MathFragment,
+ [tl, t, tr, bl, b, br]: [Option<MathFragment>; 6],
+) -> SourceResult<()> {
+ let base_class = base.class();
+
+ // Calculate the distance from the base's baseline to the superscripts' and
+ // subscripts' baseline.
+ let (tx_shift, bx_shift) = if [&tl, &tr, &bl, &br].iter().all(|e| e.is_none()) {
+ (Abs::zero(), Abs::zero())
+ } else {
+ compute_script_shifts(ctx, styles, &base, [&tl, &tr, &bl, &br])
+ };
+
+ // Calculate the distance from the base's baseline to the top attachment's
+ // and bottom attachment's baseline.
+ let (t_shift, b_shift) =
+ compute_limit_shifts(ctx, styles, &base, [t.as_ref(), b.as_ref()]);
+
+ // Calculate the final frame height.
+ let ascent = base
+ .ascent()
+ .max(tx_shift + measure!(tr, ascent))
+ .max(tx_shift + measure!(tl, ascent))
+ .max(t_shift + measure!(t, ascent));
+ let descent = base
+ .descent()
+ .max(bx_shift + measure!(br, descent))
+ .max(bx_shift + measure!(bl, descent))
+ .max(b_shift + measure!(b, descent));
+ let height = ascent + descent;
+
+ // Calculate the vertical position of each element in the final frame.
+ let base_y = ascent - base.ascent();
+ let tx_y = |tx: &MathFragment| ascent - tx_shift - tx.ascent();
+ let bx_y = |bx: &MathFragment| ascent + bx_shift - bx.ascent();
+ let t_y = |t: &MathFragment| ascent - t_shift - t.ascent();
+ let b_y = |b: &MathFragment| ascent + b_shift - b.ascent();
+
+ // Calculate the distance each limit extends to the left and right of the
+ // base's width.
+ let ((t_pre_width, t_post_width), (b_pre_width, b_post_width)) =
+ compute_limit_widths(&base, [t.as_ref(), b.as_ref()]);
+
+ // `space_after_script` is extra spacing that is at the start before each
+ // pre-script, and at the end after each post-script (see the MathConstants
+ // table in the OpenType MATH spec).
+ let space_after_script = scaled!(ctx, styles, space_after_script);
+
+ // Calculate the distance each pre-script extends to the left of the base's
+ // width.
+ let (tl_pre_width, bl_pre_width) = compute_pre_script_widths(
+ ctx,
+ &base,
+ [tl.as_ref(), bl.as_ref()],
+ (tx_shift, bx_shift),
+ space_after_script,
+ );
+
+ // Calculate the distance each post-script extends to the right of the
+ // base's width. Also calculate each post-script's kerning (we need this for
+ // its position later).
+ let ((tr_post_width, tr_kern), (br_post_width, br_kern)) = compute_post_script_widths(
+ ctx,
+ &base,
+ [tr.as_ref(), br.as_ref()],
+ (tx_shift, bx_shift),
+ space_after_script,
+ );
+
+ // Calculate the final frame width.
+ let pre_width = t_pre_width.max(b_pre_width).max(tl_pre_width).max(bl_pre_width);
+ let base_width = base.width();
+ let post_width = t_post_width.max(b_post_width).max(tr_post_width).max(br_post_width);
+ let width = pre_width + base_width + post_width;
+
+ // Calculate the horizontal position of each element in the final frame.
+ let base_x = pre_width;
+ let tl_x = pre_width - tl_pre_width + space_after_script;
+ let bl_x = pre_width - bl_pre_width + space_after_script;
+ let tr_x = pre_width + base_width + tr_kern;
+ let br_x = pre_width + base_width + br_kern;
+ let t_x = pre_width - t_pre_width;
+ let b_x = pre_width - b_pre_width;
+
+ // Create the final frame.
+ let mut frame = Frame::soft(Size::new(width, height));
+ frame.set_baseline(ascent);
+ frame.push_frame(Point::new(base_x, base_y), base.into_frame());
+
+ macro_rules! layout {
+ ($e: ident, $x: ident, $y: ident) => {
+ if let Some($e) = $e {
+ frame.push_frame(Point::new($x, $y(&$e)), $e.into_frame());
+ }
+ };
+ }
+
+ layout!(tl, tl_x, tx_y); // pre-superscript
+ layout!(bl, bl_x, bx_y); // pre-subscript
+ layout!(tr, tr_x, tx_y); // post-superscript
+ layout!(br, br_x, bx_y); // post-subscript
+ layout!(t, t_x, t_y); // upper-limit
+ layout!(b, b_x, b_y); // lower-limit
+
+ // Done! Note that we retain the class of the base.
+ ctx.push(FrameFragment::new(ctx, styles, frame).with_class(base_class));
+
+ Ok(())
+}
+
+/// Calculate the distance each post-script extends to the right of the base's
+/// width, as well as its kerning value. Requires the distance from the base's
+/// baseline to each post-script's baseline to obtain the correct kerning value.
+/// Returns 2 tuples of two lengths, each first containing the distance the
+/// post-script extends left of the base's width and second containing the
+/// post-script's kerning value. The first tuple is for the post-superscript,
+/// and the second is for the post-subscript.
+fn compute_post_script_widths(
+ ctx: &MathContext,
+ base: &MathFragment,
+ [tr, br]: [Option<&MathFragment>; 2],
+ (tr_shift, br_shift): (Abs, Abs),
+ space_after_post_script: Abs,
+) -> ((Abs, Abs), (Abs, Abs)) {
+ let tr_values = tr.map_or_default(|tr| {
+ let kern = math_kern(ctx, base, tr, tr_shift, Corner::TopRight);
+ (space_after_post_script + tr.width() + kern, kern)
+ });
+
+ // The base's bounding box already accounts for its italic correction, so we
+ // need to shift the post-subscript left by the base's italic correction
+ // (see the kerning algorithm as described in the OpenType MATH spec).
+ let br_values = br.map_or_default(|br| {
+ let kern = math_kern(ctx, base, br, br_shift, Corner::BottomRight)
+ - base.italics_correction();
+ (space_after_post_script + br.width() + kern, kern)
+ });
+
+ (tr_values, br_values)
+}
+
+/// Calculate the distance each pre-script extends to the left of the base's
+/// width. Requires the distance from the base's baseline to each pre-script's
+/// baseline to obtain the correct kerning value.
+/// Returns two lengths, the first being the distance the pre-superscript
+/// extends left of the base's width and the second being the distance the
+/// pre-subscript extends left of the base's width.
+fn compute_pre_script_widths(
+ ctx: &MathContext,
+ base: &MathFragment,
+ [tl, bl]: [Option<&MathFragment>; 2],
+ (tl_shift, bl_shift): (Abs, Abs),
+ space_before_pre_script: Abs,
+) -> (Abs, Abs) {
+ let tl_pre_width = tl.map_or_default(|tl| {
+ let kern = math_kern(ctx, base, tl, tl_shift, Corner::TopLeft);
+ space_before_pre_script + tl.width() + kern
+ });
+
+ let bl_pre_width = bl.map_or_default(|bl| {
+ let kern = math_kern(ctx, base, bl, bl_shift, Corner::BottomLeft);
+ space_before_pre_script + bl.width() + kern
+ });
+
+ (tl_pre_width, bl_pre_width)
+}
+
+/// Calculate the distance each limit extends beyond the base's width, in each
+/// direction. Can be a negative value if the limit does not extend beyond the
+/// base's width, indicating how far into the base's width the limit extends.
+/// Returns 2 tuples of two lengths, each first containing the distance the
+/// limit extends leftward beyond the base's width and second containing the
+/// distance the limit extends rightward beyond the base's width. The first
+/// tuple is for the upper-limit, and the second is for the lower-limit.
+fn compute_limit_widths(
+ base: &MathFragment,
+ [t, b]: [Option<&MathFragment>; 2],
+) -> ((Abs, Abs), (Abs, Abs)) {
+ // The upper- (lower-) limit is shifted to the right (left) of the base's
+ // center by half the base's italic correction.
+ let delta = base.italics_correction() / 2.0;
+
+ let t_widths = t.map_or_default(|t| {
+ let half = (t.width() - base.width()) / 2.0;
+ (half - delta, half + delta)
+ });
+
+ let b_widths = b.map_or_default(|b| {
+ let half = (b.width() - base.width()) / 2.0;
+ (half + delta, half - delta)
+ });
+
+ (t_widths, b_widths)
+}
+
+/// Calculate the distance from the base's baseline to each limit's baseline.
+/// Returns two lengths, the first being the distance to the upper-limit's
+/// baseline and the second being the distance to the lower-limit's baseline.
+fn compute_limit_shifts(
+ ctx: &MathContext,
+ styles: StyleChain,
+ base: &MathFragment,
+ [t, b]: [Option<&MathFragment>; 2],
+) -> (Abs, Abs) {
+ // `upper_gap_min` and `lower_gap_min` give gaps to the descender and
+ // ascender of the limits respectively, whereas `upper_rise_min` and
+ // `lower_drop_min` give gaps to each limit's baseline (see the
+ // MathConstants table in the OpenType MATH spec).
+
+ let t_shift = t.map_or_default(|t| {
+ let upper_gap_min = scaled!(ctx, styles, upper_limit_gap_min);
+ let upper_rise_min = scaled!(ctx, styles, upper_limit_baseline_rise_min);
+ base.ascent() + upper_rise_min.max(upper_gap_min + t.descent())
+ });
+
+ let b_shift = b.map_or_default(|b| {
+ let lower_gap_min = scaled!(ctx, styles, lower_limit_gap_min);
+ let lower_drop_min = scaled!(ctx, styles, lower_limit_baseline_drop_min);
+ base.descent() + lower_drop_min.max(lower_gap_min + b.ascent())
+ });
+
+ (t_shift, b_shift)
+}
+
+/// Calculate the distance from the base's baseline to each script's baseline.
+/// Returns two lengths, the first being the distance to the superscripts'
+/// baseline and the second being the distance to the subscripts' baseline.
+fn compute_script_shifts(
+ ctx: &MathContext,
+ styles: StyleChain,
+ base: &MathFragment,
+ [tl, tr, bl, br]: [&Option<MathFragment>; 4],
+) -> (Abs, Abs) {
+ let sup_shift_up = if EquationElem::cramped_in(styles) {
+ scaled!(ctx, styles, superscript_shift_up_cramped)
+ } else {
+ scaled!(ctx, styles, superscript_shift_up)
+ };
+
+ 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();
+ let is_text_like = base.is_text_like();
+
+ if tl.is_some() || tr.is_some() {
+ let ascent = match &base {
+ MathFragment::Frame(frame) => frame.base_ascent,
+ _ => base.ascent(),
+ };
+ shift_up = shift_up
+ .max(sup_shift_up)
+ .max(if is_text_like { Abs::zero() } else { ascent - sup_drop_max })
+ .max(sup_bottom_min + measure!(tl, descent))
+ .max(sup_bottom_min + measure!(tr, descent));
+ }
+
+ if bl.is_some() || br.is_some() {
+ shift_down = shift_down
+ .max(sub_shift_down)
+ .max(if is_text_like { Abs::zero() } else { base.descent() + sub_drop_min })
+ .max(measure!(bl, ascent) - sub_top_max)
+ .max(measure!(br, ascent) - sub_top_max);
+ }
+
+ for (sup, sub) in [(tl, bl), (tr, br)] {
+ if let (Some(sup), Some(sub)) = (&sup, &sub) {
+ let sup_bottom = shift_up - sup.descent();
+ let sub_top = sub.ascent() - shift_down;
+ let gap = sup_bottom - sub_top;
+ if gap >= gap_min {
+ continue;
+ }
+
+ let increase = gap_min - gap;
+ let sup_only =
+ (sup_bottom_max_with_sub - sup_bottom).clamp(Abs::zero(), increase);
+ let rest = (increase - sup_only) / 2.0;
+ shift_up += sup_only + rest;
+ shift_down += rest;
+ }
+ }
+
+ (shift_up, shift_down)
+}
+
+/// Calculate the kerning value for a script with respect to the base. A
+/// positive value means shifting the script further away from the base, whereas
+/// a negative value means shifting the script closer to the base. Requires the
+/// distance from the base's baseline to the script's baseline, as well as the
+/// script's corner (tl, tr, bl, br).
+fn math_kern(
+ ctx: &MathContext,
+ base: &MathFragment,
+ script: &MathFragment,
+ shift: Abs,
+ pos: Corner,
+) -> Abs {
+ // This process is described under the MathKernInfo table in the OpenType
+ // MATH spec.
+
+ let (corr_height_top, corr_height_bot) = match pos {
+ // Calculate two correction heights for superscripts:
+ // - The distance from the superscript's baseline to the top of the
+ // base's bounding box.
+ // - The distance from the base's baseline to the bottom of the
+ // superscript's bounding box.
+ Corner::TopLeft | Corner::TopRight => {
+ (base.ascent() - shift, shift - script.descent())
+ }
+ // Calculate two correction heights for subscripts:
+ // - The distance from the base's baseline to the top of the
+ // subscript's bounding box.
+ // - The distance from the subscript's baseline to the bottom of the
+ // base's bounding box.
+ Corner::BottomLeft | Corner::BottomRight => {
+ (script.ascent() - shift, shift - base.descent())
+ }
+ };
+
+ // Calculate the sum of kerning values for each correction height.
+ let summed_kern = |height| {
+ let base_kern = base.kern_at_height(ctx, pos, height);
+ let attach_kern = script.kern_at_height(ctx, pos.inv(), height);
+ base_kern + attach_kern
+ };
+
+ // Take the smaller kerning amount (and so the larger value). Note that
+ // there is a bug in the spec (as of 2024-08-15): it says to take the
+ // minimum of the two sums, but as the kerning value is usually negative it
+ // really means the smaller kern. The current wording of the spec could
+ // result in glyphs colliding.
+ summed_kern(corr_height_top).max(summed_kern(corr_height_bot))
+}
diff --git a/crates/typst-layout/src/math/cancel.rs b/crates/typst-layout/src/math/cancel.rs
new file mode 100644
index 00000000..994e0e2f
--- /dev/null
+++ b/crates/typst-layout/src/math/cancel.rs
@@ -0,0 +1,144 @@
+use comemo::Track;
+use typst_library::diag::{At, SourceResult};
+use typst_library::foundations::{Context, Packed, Smart, StyleChain};
+use typst_library::layout::{Abs, Angle, Frame, FrameItem, Point, Rel, Size, Transform};
+use typst_library::math::{CancelAngle, CancelElem};
+use typst_library::text::TextElem;
+use typst_library::visualize::{FixedStroke, Geometry};
+use typst_syntax::Span;
+
+use super::{scaled_font_size, FrameFragment, MathContext};
+
+/// Lays out a [`CancelElem`].
+#[typst_macros::time(name = "math.cancel", span = elem.span())]
+pub fn layout_cancel(
+ elem: &Packed<CancelElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let body = ctx.layout_into_fragment(elem.body(), styles)?;
+
+ // Preserve properties of body.
+ 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 body_size = body.size();
+ let span = elem.span();
+ let length = elem.length(styles).at(scaled_font_size(ctx, styles));
+
+ let stroke = elem.stroke(styles).unwrap_or(FixedStroke {
+ paint: TextElem::fill_in(styles).as_decoration(),
+ ..Default::default()
+ });
+
+ let invert = elem.inverted(styles);
+ let cross = elem.cross(styles);
+ let angle = elem.angle(styles);
+
+ let invert_first_line = !cross && invert;
+ let first_line = draw_cancel_line(
+ ctx,
+ length,
+ stroke.clone(),
+ invert_first_line,
+ &angle,
+ body_size,
+ styles,
+ span,
+ )?;
+
+ // The origin of our line is the very middle of the element.
+ let center = body_size.to_point() / 2.0;
+ body.push_frame(center, first_line);
+
+ if cross {
+ // Draw the second line.
+ let second_line =
+ draw_cancel_line(ctx, length, stroke, true, &angle, body_size, styles, span)?;
+
+ body.push_frame(center, second_line);
+ }
+
+ ctx.push(
+ FrameFragment::new(ctx, styles, body)
+ .with_class(body_class)
+ .with_italics_correction(body_italics)
+ .with_accent_attach(body_attach)
+ .with_text_like(body_text_like),
+ );
+
+ Ok(())
+}
+
+/// Draws a cancel line.
+#[allow(clippy::too_many_arguments)]
+fn draw_cancel_line(
+ ctx: &mut MathContext,
+ length_scale: Rel<Abs>,
+ stroke: FixedStroke,
+ invert: bool,
+ angle: &Smart<CancelAngle>,
+ body_size: Size,
+ styles: StyleChain,
+ span: Span,
+) -> SourceResult<Frame> {
+ let default = default_angle(body_size);
+ let mut angle = match angle {
+ // Non specified angle defaults to the diagonal
+ Smart::Auto => default,
+ Smart::Custom(angle) => match angle {
+ // This specifies the absolute angle w.r.t y-axis clockwise.
+ CancelAngle::Angle(v) => *v,
+ // This specifies a function that takes the default angle as input.
+ CancelAngle::Func(func) => func
+ .call(ctx.engine, Context::new(None, Some(styles)).track(), [default])?
+ .cast()
+ .at(span)?,
+ },
+ };
+
+ // invert means flipping along the y-axis
+ if invert {
+ angle *= -1.0;
+ }
+
+ // same as above, the default length is the diagonal of the body box.
+ let default_length = body_size.to_point().hypot();
+ let length = length_scale.relative_to(default_length);
+
+ // Draw a vertical line of length and rotate it by angle
+ let start = Point::new(Abs::zero(), length / 2.0);
+ let delta = Point::new(Abs::zero(), -length);
+
+ let mut frame = Frame::soft(body_size);
+ frame.push(start, FrameItem::Shape(Geometry::Line(delta).stroked(stroke), span));
+
+ // Having the middle of the line at the origin is convenient here.
+ frame.transform(Transform::rotate(angle));
+ Ok(frame)
+}
+
+/// The default line angle for a body of the given size.
+fn default_angle(body: Size) -> Angle {
+ // The default cancel line is the diagonal.
+ // We infer the default angle from
+ // the diagonal w.r.t to the body box.
+ //
+ // The returned angle is in the range of [0, Pi/2]
+ //
+ // Note that the angle is computed w.r.t to the y-axis
+ //
+ // B
+ // /|
+ // diagonal / | height
+ // / |
+ // / |
+ // O ----
+ // width
+ let (width, height) = (body.x, body.y);
+ let default_angle = (width / height).atan(); // arctangent (in the range [0, Pi/2])
+ Angle::rad(default_angle)
+}
diff --git a/crates/typst-layout/src/math/frac.rs b/crates/typst-layout/src/math/frac.rs
new file mode 100644
index 00000000..50686333
--- /dev/null
+++ b/crates/typst-layout/src/math/frac.rs
@@ -0,0 +1,136 @@
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Content, Packed, StyleChain};
+use typst_library::layout::{Em, Frame, FrameItem, Point, Size};
+use typst_library::math::{BinomElem, FracElem};
+use typst_library::text::TextElem;
+use typst_library::visualize::{FixedStroke, Geometry};
+use typst_syntax::Span;
+
+use super::{
+ scaled_font_size, style_for_denominator, style_for_numerator, FrameFragment,
+ GlyphFragment, MathContext, DELIM_SHORT_FALL,
+};
+
+const FRAC_AROUND: Em = Em::new(0.1);
+
+/// Lays out a [`FracElem`].
+#[typst_macros::time(name = "math.frac", span = elem.span())]
+pub fn layout_frac(
+ elem: &Packed<FracElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_frac_like(
+ ctx,
+ styles,
+ elem.num(),
+ std::slice::from_ref(elem.denom()),
+ false,
+ elem.span(),
+ )
+}
+
+/// Lays out a [`BinomElem`].
+#[typst_macros::time(name = "math.binom", span = elem.span())]
+pub fn layout_binom(
+ elem: &Packed<BinomElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_frac_like(ctx, styles, elem.upper(), elem.lower(), true, elem.span())
+}
+
+/// Layout a fraction or binomial.
+fn layout_frac_like(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ num: &Content,
+ denom: &[Content],
+ binom: bool,
+ span: Span,
+) -> SourceResult<()> {
+ 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, styles,
+ text: fraction_numerator_shift_up,
+ display: fraction_numerator_display_style_shift_up,
+ );
+ let shift_down = scaled!(
+ ctx, styles,
+ text: fraction_denominator_shift_down,
+ display: fraction_denominator_display_style_shift_down,
+ );
+ let num_min = scaled!(
+ ctx, styles,
+ text: fraction_numerator_gap_min,
+ display: fraction_num_display_style_gap_min,
+ );
+ let denom_min = scaled!(
+ ctx, styles,
+ text: fraction_denominator_gap_min,
+ display: fraction_denom_display_style_gap_min,
+ );
+
+ let num_style = style_for_numerator(styles);
+ let num = ctx.layout_into_frame(num, styles.chain(&num_style))?;
+
+ let denom_style = style_for_denominator(styles);
+ let denom = ctx.layout_into_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.at(font_size);
+ let num_gap = (shift_up - (axis + thickness / 2.0) - num.descent()).max(num_min);
+ let denom_gap =
+ (shift_down + (axis - thickness / 2.0) - denom.ascent()).max(denom_min);
+
+ let line_width = num.width().max(denom.width());
+ let width = line_width + 2.0 * around;
+ let height = num.height() + num_gap + thickness + denom_gap + denom.height();
+ let size = Size::new(width, height);
+ let num_pos = Point::with_x((width - num.width()) / 2.0);
+ let line_pos =
+ Point::new((width - line_width) / 2.0, num.height() + num_gap + thickness / 2.0);
+ let denom_pos = Point::new((width - denom.width()) / 2.0, height - denom.height());
+ let baseline = line_pos.y + axis;
+
+ let mut frame = Frame::soft(size);
+ frame.set_baseline(baseline);
+ frame.push_frame(num_pos, num);
+ frame.push_frame(denom_pos, denom);
+
+ if binom {
+ 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, 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 {
+ frame.push(
+ line_pos,
+ FrameItem::Shape(
+ Geometry::Line(Point::with_x(line_width)).stroked(
+ FixedStroke::from_pair(
+ TextElem::fill_in(styles).as_decoration(),
+ thickness,
+ ),
+ ),
+ span,
+ ),
+ );
+ ctx.push(FrameFragment::new(ctx, styles, frame));
+ }
+
+ Ok(())
+}
diff --git a/crates/typst-layout/src/math/fragment.rs b/crates/typst-layout/src/math/fragment.rs
new file mode 100644
index 00000000..19a4494e
--- /dev/null
+++ b/crates/typst-layout/src/math/fragment.rs
@@ -0,0 +1,704 @@
+use std::fmt::{self, Debug, Formatter};
+
+use rustybuzz::Feature;
+use smallvec::SmallVec;
+use ttf_parser::gsub::{
+ AlternateSet, AlternateSubstitution, SingleSubstitution, SubstitutionSubtable,
+};
+use ttf_parser::opentype_layout::LayoutTable;
+use ttf_parser::{GlyphId, Rect};
+use typst_library::foundations::StyleChain;
+use typst_library::introspection::Tag;
+use typst_library::layout::{
+ Abs, Axis, Corner, Em, Frame, FrameItem, HideElem, Point, Size, VAlignment,
+};
+use typst_library::math::{EquationElem, MathSize};
+use typst_library::model::{Destination, LinkElem};
+use typst_library::text::{Font, Glyph, Lang, Region, TextElem, TextItem};
+use typst_library::visualize::Paint;
+use typst_syntax::Span;
+use unicode_math_class::MathClass;
+
+use super::{scaled_font_size, stretch_glyph, MathContext, Scaled};
+
+#[derive(Debug, Clone)]
+pub enum MathFragment {
+ Glyph(GlyphFragment),
+ Variant(VariantFragment),
+ Frame(FrameFragment),
+ Spacing(Abs, bool),
+ Space(Abs),
+ Linebreak,
+ Align,
+ Tag(Tag),
+}
+
+impl MathFragment {
+ pub fn size(&self) -> Size {
+ Size::new(self.width(), self.height())
+ }
+
+ pub fn width(&self) -> Abs {
+ match self {
+ Self::Glyph(glyph) => glyph.width,
+ Self::Variant(variant) => variant.frame.width(),
+ Self::Frame(fragment) => fragment.frame.width(),
+ Self::Spacing(amount, _) => *amount,
+ Self::Space(amount) => *amount,
+ _ => Abs::zero(),
+ }
+ }
+
+ pub fn height(&self) -> Abs {
+ match self {
+ Self::Glyph(glyph) => glyph.height(),
+ Self::Variant(variant) => variant.frame.height(),
+ Self::Frame(fragment) => fragment.frame.height(),
+ _ => Abs::zero(),
+ }
+ }
+
+ pub fn ascent(&self) -> Abs {
+ match self {
+ Self::Glyph(glyph) => glyph.ascent,
+ Self::Variant(variant) => variant.frame.ascent(),
+ Self::Frame(fragment) => fragment.frame.baseline(),
+ _ => Abs::zero(),
+ }
+ }
+
+ pub fn descent(&self) -> Abs {
+ match self {
+ Self::Glyph(glyph) => glyph.descent,
+ Self::Variant(variant) => variant.frame.descent(),
+ Self::Frame(fragment) => fragment.frame.descent(),
+ _ => Abs::zero(),
+ }
+ }
+
+ pub fn is_ignorant(&self) -> bool {
+ match self {
+ Self::Frame(fragment) => fragment.ignorant,
+ Self::Tag(_) => true,
+ _ => false,
+ }
+ }
+
+ pub fn class(&self) -> MathClass {
+ match self {
+ Self::Glyph(glyph) => glyph.class,
+ Self::Variant(variant) => variant.class,
+ Self::Frame(fragment) => fragment.class,
+ Self::Spacing(_, _) => MathClass::Space,
+ Self::Space(_) => MathClass::Space,
+ Self::Linebreak => MathClass::Space,
+ Self::Align => MathClass::Special,
+ Self::Tag(_) => MathClass::Special,
+ }
+ }
+
+ pub fn math_size(&self) -> Option<MathSize> {
+ match self {
+ Self::Glyph(glyph) => Some(glyph.math_size),
+ Self::Variant(variant) => Some(variant.math_size),
+ Self::Frame(fragment) => Some(fragment.math_size),
+ _ => None,
+ }
+ }
+
+ pub fn font_size(&self) -> Option<Abs> {
+ match self {
+ Self::Glyph(glyph) => Some(glyph.font_size),
+ Self::Variant(variant) => Some(variant.font_size),
+ Self::Frame(fragment) => Some(fragment.font_size),
+ _ => None,
+ }
+ }
+
+ pub fn set_class(&mut self, class: MathClass) {
+ match self {
+ Self::Glyph(glyph) => glyph.class = class,
+ Self::Variant(variant) => variant.class = class,
+ Self::Frame(fragment) => fragment.class = class,
+ _ => {}
+ }
+ }
+
+ pub fn set_limits(&mut self, limits: Limits) {
+ match self {
+ Self::Glyph(glyph) => glyph.limits = limits,
+ Self::Variant(variant) => variant.limits = limits,
+ Self::Frame(fragment) => fragment.limits = limits,
+ _ => {}
+ }
+ }
+
+ pub fn is_spaced(&self) -> bool {
+ if self.class() == MathClass::Fence {
+ return true;
+ }
+
+ matches!(
+ self,
+ MathFragment::Frame(FrameFragment {
+ spaced: true,
+ class: MathClass::Normal | MathClass::Alphabetic,
+ ..
+ })
+ )
+ }
+
+ pub fn is_text_like(&self) -> bool {
+ match self {
+ Self::Glyph(_) | Self::Variant(_) => self.class() != MathClass::Large,
+ MathFragment::Frame(frame) => frame.text_like,
+ _ => false,
+ }
+ }
+
+ pub fn italics_correction(&self) -> Abs {
+ match self {
+ Self::Glyph(glyph) => glyph.italics_correction,
+ Self::Variant(variant) => variant.italics_correction,
+ Self::Frame(fragment) => fragment.italics_correction,
+ _ => Abs::zero(),
+ }
+ }
+
+ pub fn accent_attach(&self) -> Abs {
+ match self {
+ Self::Glyph(glyph) => glyph.accent_attach,
+ Self::Variant(variant) => variant.accent_attach,
+ Self::Frame(fragment) => fragment.accent_attach,
+ _ => self.width() / 2.0,
+ }
+ }
+
+ pub fn into_frame(self) -> Frame {
+ match self {
+ Self::Glyph(glyph) => glyph.into_frame(),
+ Self::Variant(variant) => variant.frame,
+ Self::Frame(fragment) => fragment.frame,
+ Self::Tag(tag) => {
+ let mut frame = Frame::soft(Size::zero());
+ frame.push(Point::zero(), FrameItem::Tag(tag));
+ frame
+ }
+ _ => Frame::soft(self.size()),
+ }
+ }
+
+ pub fn limits(&self) -> Limits {
+ match self {
+ MathFragment::Glyph(glyph) => glyph.limits,
+ MathFragment::Variant(variant) => variant.limits,
+ MathFragment::Frame(fragment) => fragment.limits,
+ _ => Limits::Never,
+ }
+ }
+
+ /// If no kern table is provided for a corner, a kerning amount of zero is
+ /// assumed.
+ pub fn kern_at_height(&self, ctx: &MathContext, corner: Corner, height: Abs) -> Abs {
+ match self {
+ Self::Glyph(glyph) => {
+ kern_at_height(ctx, glyph.font_size, glyph.id, corner, height)
+ .unwrap_or_default()
+ }
+ _ => Abs::zero(),
+ }
+ }
+}
+
+impl From<GlyphFragment> for MathFragment {
+ fn from(glyph: GlyphFragment) -> Self {
+ Self::Glyph(glyph)
+ }
+}
+
+impl From<VariantFragment> for MathFragment {
+ fn from(variant: VariantFragment) -> Self {
+ Self::Variant(variant)
+ }
+}
+
+impl From<FrameFragment> for MathFragment {
+ fn from(fragment: FrameFragment) -> Self {
+ Self::Frame(fragment)
+ }
+}
+
+#[derive(Clone)]
+pub struct GlyphFragment {
+ pub id: GlyphId,
+ pub c: char,
+ pub font: Font,
+ pub lang: Lang,
+ pub region: Option<Region>,
+ pub fill: Paint,
+ pub shift: Abs,
+ pub width: Abs,
+ pub ascent: Abs,
+ pub descent: Abs,
+ pub italics_correction: Abs,
+ pub accent_attach: Abs,
+ pub font_size: Abs,
+ pub class: MathClass,
+ pub math_size: MathSize,
+ pub span: Span,
+ pub dests: SmallVec<[Destination; 1]>,
+ pub hidden: bool,
+ pub limits: Limits,
+}
+
+impl GlyphFragment {
+ 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, styles, c, id, span)
+ }
+
+ pub fn try_new(
+ ctx: &MathContext,
+ styles: StyleChain,
+ c: char,
+ span: Span,
+ ) -> Option<Self> {
+ let id = ctx.ttf.glyph_index(c)?;
+ let id = Self::adjust_glyph_index(ctx, id);
+ Some(Self::with_id(ctx, styles, c, id, span))
+ }
+
+ 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(styles),
+ region: TextElem::region_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(),
+ limits: Limits::for_char(c),
+ italics_correction: Abs::zero(),
+ accent_attach: Abs::zero(),
+ class,
+ span,
+ dests: LinkElem::dests_in(styles),
+ hidden: HideElem::hidden_in(styles),
+ };
+ fragment.set_id(ctx, id);
+ fragment
+ }
+
+ /// Apply GSUB substitutions.
+ fn adjust_glyph_index(ctx: &MathContext, id: GlyphId) -> GlyphId {
+ if let Some(glyphwise_tables) = &ctx.glyphwise_tables {
+ glyphwise_tables.iter().fold(id, |id, table| table.apply(id))
+ } else {
+ id
+ }
+ }
+
+ /// Sets element id and boxes in appropriate way without changing other
+ /// 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, self.font_size).unwrap_or_default();
+ let bbox = ctx.ttf.glyph_bounding_box(id).unwrap_or(Rect {
+ x_min: 0,
+ y_min: 0,
+ x_max: 0,
+ y_max: 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;
+ }
+
+ self.id = id;
+ self.width = width;
+ 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;
+ }
+
+ pub fn height(&self) -> Abs {
+ self.ascent + self.descent
+ }
+
+ pub fn into_variant(self) -> VariantFragment {
+ VariantFragment {
+ c: self.c,
+ 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(),
+ mid_stretched: None,
+ }
+ }
+
+ pub fn into_frame(self) -> Frame {
+ let item = TextItem {
+ font: self.font.clone(),
+ size: self.font_size,
+ fill: self.fill,
+ lang: self.lang,
+ region: self.region,
+ text: self.c.into(),
+ stroke: None,
+ glyphs: vec![Glyph {
+ id: self.id.0,
+ x_advance: Em::from_length(self.width, self.font_size),
+ x_offset: Em::zero(),
+ range: 0..self.c.len_utf8() as u16,
+ span: (self.span, 0),
+ }],
+ };
+ let size = Size::new(self.width, self.ascent + self.descent);
+ let mut frame = Frame::soft(size);
+ frame.set_baseline(self.ascent);
+ frame.push(Point::with_y(self.ascent + self.shift), FrameItem::Text(item));
+ frame.post_process_raw(self.dests, self.hidden);
+ frame
+ }
+
+ pub fn make_scriptsize(&mut self, ctx: &MathContext) {
+ let alt_id =
+ script_alternatives(ctx, self.id).and_then(|alts| alts.alternates.get(0));
+
+ if let Some(alt_id) = alt_id {
+ self.set_id(ctx, alt_id);
+ }
+ }
+
+ pub fn make_scriptscriptsize(&mut self, ctx: &MathContext) {
+ let alts = script_alternatives(ctx, self.id);
+ let alt_id = alts
+ .and_then(|alts| alts.alternates.get(1).or_else(|| alts.alternates.get(0)));
+
+ if let Some(alt_id) = alt_id {
+ self.set_id(ctx, alt_id);
+ }
+ }
+
+ /// Try to stretch a glyph to a desired height.
+ pub fn stretch_vertical(
+ self,
+ ctx: &MathContext,
+ height: Abs,
+ short_fall: Abs,
+ ) -> VariantFragment {
+ stretch_glyph(ctx, self, height, short_fall, Axis::Y)
+ }
+
+ /// Try to stretch a glyph to a desired width.
+ pub fn stretch_horizontal(
+ self,
+ ctx: &MathContext,
+ width: Abs,
+ short_fall: Abs,
+ ) -> VariantFragment {
+ stretch_glyph(ctx, self, width, short_fall, Axis::X)
+ }
+}
+
+impl Debug for GlyphFragment {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ write!(f, "GlyphFragment({:?})", self.c)
+ }
+}
+
+#[derive(Clone)]
+pub struct VariantFragment {
+ pub c: char,
+ pub italics_correction: Abs,
+ pub accent_attach: Abs,
+ pub frame: Frame,
+ pub font_size: Abs,
+ pub class: MathClass,
+ pub math_size: MathSize,
+ pub span: Span,
+ pub limits: Limits,
+ pub mid_stretched: Option<bool>,
+}
+
+impl VariantFragment {
+ /// Vertically adjust the fragment's frame so that it is centered
+ /// on the axis.
+ pub fn center_on_axis(&mut self, ctx: &MathContext) {
+ self.align_on_axis(ctx, VAlignment::Horizon)
+ }
+
+ /// Vertically adjust the fragment's frame so that it is aligned
+ /// to the given alignment on the axis.
+ pub fn align_on_axis(&mut self, ctx: &MathContext, align: VAlignment) {
+ let h = self.frame.height();
+ let axis = ctx.constants.axis_height().scaled(ctx, self.font_size);
+ self.frame.set_baseline(align.inv().position(h + axis * 2.0));
+ }
+}
+
+impl Debug for VariantFragment {
+ fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+ write!(f, "VariantFragment({:?})", self.c)
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct FrameFragment {
+ pub frame: Frame,
+ pub font_size: Abs,
+ pub class: MathClass,
+ pub math_size: MathSize,
+ pub limits: Limits,
+ pub spaced: bool,
+ pub base_ascent: Abs,
+ pub italics_correction: Abs,
+ pub accent_attach: Abs,
+ pub text_like: bool,
+ pub ignorant: bool,
+}
+
+impl FrameFragment {
+ pub fn new(ctx: &MathContext, styles: StyleChain, frame: Frame) -> Self {
+ let base_ascent = frame.ascent();
+ let accent_attach = frame.width() / 2.0;
+ Self {
+ frame: frame.post_processed(styles),
+ 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,
+ italics_correction: Abs::zero(),
+ accent_attach,
+ text_like: false,
+ ignorant: false,
+ }
+ }
+
+ pub fn with_class(self, class: MathClass) -> Self {
+ Self { class, ..self }
+ }
+
+ pub fn with_limits(self, limits: Limits) -> Self {
+ Self { limits, ..self }
+ }
+
+ pub fn with_spaced(self, spaced: bool) -> Self {
+ Self { spaced, ..self }
+ }
+
+ pub fn with_base_ascent(self, base_ascent: Abs) -> Self {
+ Self { base_ascent, ..self }
+ }
+
+ pub fn with_italics_correction(self, italics_correction: Abs) -> Self {
+ Self { italics_correction, ..self }
+ }
+
+ pub fn with_accent_attach(self, accent_attach: Abs) -> Self {
+ Self { accent_attach, ..self }
+ }
+
+ pub fn with_text_like(self, text_like: bool) -> Self {
+ Self { text_like, ..self }
+ }
+
+ pub fn with_ignorant(self, ignorant: bool) -> Self {
+ Self { ignorant, ..self }
+ }
+}
+
+/// Look up the italics correction for a glyph.
+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, 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
+fn script_alternatives<'a>(
+ ctx: &MathContext<'a, '_, '_>,
+ id: GlyphId,
+) -> Option<AlternateSet<'a>> {
+ ctx.ssty_table.and_then(|ssty| {
+ ssty.coverage.get(id).and_then(|index| ssty.alternate_sets.get(index))
+ })
+}
+
+/// Look up whether a glyph is an extended shape.
+fn is_extended_shape(ctx: &MathContext, id: GlyphId) -> bool {
+ ctx.table
+ .glyph_info
+ .and_then(|info| info.extended_shapes)
+ .and_then(|info| info.get(id))
+ .is_some()
+}
+
+/// Look up a kerning value at a specific corner and height.
+fn kern_at_height(
+ ctx: &MathContext,
+ font_size: Abs,
+ id: GlyphId,
+ corner: Corner,
+ height: Abs,
+) -> Option<Abs> {
+ let kerns = ctx.table.glyph_info?.kern_infos?.get(id)?;
+ let kern = match corner {
+ Corner::TopLeft => kerns.top_left,
+ Corner::TopRight => kerns.top_right,
+ Corner::BottomRight => kerns.bottom_right,
+ Corner::BottomLeft => kerns.bottom_left,
+ }?;
+
+ let mut i = 0;
+ while i < kern.count() && height > kern.height(i)?.scaled(ctx, font_size) {
+ i += 1;
+ }
+
+ Some(kern.kern(i)?.scaled(ctx, font_size))
+}
+
+/// Describes in which situation a frame should use limits for attachments.
+#[derive(Debug, Copy, Clone)]
+pub enum Limits {
+ /// Always scripts.
+ Never,
+ /// Display limits only in `display` math.
+ Display,
+ /// Always limits.
+ Always,
+}
+
+impl Limits {
+ /// The default limit configuration if the given character is the base.
+ pub fn for_char(c: char) -> Self {
+ match unicode_math_class::class(c) {
+ Some(MathClass::Large) => {
+ if is_integral_char(c) {
+ Limits::Never
+ } else {
+ Limits::Display
+ }
+ }
+ Some(MathClass::Relation) => Limits::Always,
+ _ => Limits::Never,
+ }
+ }
+
+ /// The default limit configuration for a math class.
+ pub fn for_class(class: MathClass) -> Self {
+ match class {
+ MathClass::Large => Self::Display,
+ MathClass::Relation => Self::Always,
+ _ => Self::Never,
+ }
+ }
+
+ /// Whether limits should be displayed in this context.
+ pub fn active(&self, styles: StyleChain) -> bool {
+ match self {
+ Self::Always => true,
+ Self::Display => EquationElem::size_in(styles) == MathSize::Display,
+ Self::Never => false,
+ }
+ }
+}
+
+/// Determines if the character is one of a variety of integral signs.
+fn is_integral_char(c: char) -> bool {
+ ('∫'..='∳').contains(&c) || ('⨋'..='⨜').contains(&c)
+}
+
+/// An OpenType substitution table that is applicable to glyph-wise substitutions.
+pub enum GlyphwiseSubsts<'a> {
+ Single(SingleSubstitution<'a>),
+ Alternate(AlternateSubstitution<'a>, u32),
+}
+
+impl<'a> GlyphwiseSubsts<'a> {
+ pub fn new(gsub: LayoutTable<'a>, feature: Feature) -> Option<Self> {
+ let table = gsub
+ .features
+ .find(ttf_parser::Tag(feature.tag.0))
+ .and_then(|feature| feature.lookup_indices.get(0))
+ .and_then(|index| gsub.lookups.get(index))?;
+ let table = table.subtables.get::<SubstitutionSubtable>(0)?;
+ match table {
+ SubstitutionSubtable::Single(single_glyphs) => {
+ Some(Self::Single(single_glyphs))
+ }
+ SubstitutionSubtable::Alternate(alt_glyphs) => {
+ Some(Self::Alternate(alt_glyphs, feature.value))
+ }
+ _ => None,
+ }
+ }
+
+ pub fn try_apply(&self, glyph_id: GlyphId) -> Option<GlyphId> {
+ match self {
+ Self::Single(single) => match single {
+ SingleSubstitution::Format1 { coverage, delta } => coverage
+ .get(glyph_id)
+ .map(|_| GlyphId(glyph_id.0.wrapping_add(*delta as u16))),
+ SingleSubstitution::Format2 { coverage, substitutes } => {
+ coverage.get(glyph_id).and_then(|idx| substitutes.get(idx))
+ }
+ },
+ Self::Alternate(alternate, value) => alternate
+ .coverage
+ .get(glyph_id)
+ .and_then(|idx| alternate.alternate_sets.get(idx))
+ .and_then(|set| set.alternates.get(*value as u16)),
+ }
+ }
+
+ pub fn apply(&self, glyph_id: GlyphId) -> GlyphId {
+ self.try_apply(glyph_id).unwrap_or(glyph_id)
+ }
+}
diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs
new file mode 100644
index 00000000..aba9012f
--- /dev/null
+++ b/crates/typst-layout/src/math/lr.rs
@@ -0,0 +1,135 @@
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Packed, Smart, StyleChain};
+use typst_library::layout::{Abs, Axis, Length, Rel};
+use typst_library::math::{EquationElem, LrElem, MidElem};
+use unicode_math_class::MathClass;
+
+use super::{stretch_fragment, MathContext, MathFragment, DELIM_SHORT_FALL};
+
+/// Lays out an [`LrElem`].
+#[typst_macros::time(name = "math.lr", span = elem.span())]
+pub fn layout_lr(
+ elem: &Packed<LrElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let mut body = elem.body();
+
+ // Extract from an EquationElem.
+ if let Some(equation) = body.to_packed::<EquationElem>() {
+ body = equation.body();
+ }
+
+ // Extract implicit LrElem.
+ if let Some(lr) = body.to_packed::<LrElem>() {
+ if lr.size(styles).is_auto() {
+ body = lr.body();
+ }
+ }
+
+ let mut fragments = ctx.layout_into_fragments(body, styles)?;
+ let axis = scaled!(ctx, styles, axis_height);
+ let max_extent = fragments
+ .iter()
+ .map(|fragment| (fragment.ascent() - axis).max(fragment.descent() + axis))
+ .max()
+ .unwrap_or_default();
+
+ let relative_to = 2.0 * max_extent;
+ let height = elem.size(styles);
+
+ // Scale up fragments at both ends.
+ match fragments.as_mut_slice() {
+ [one] => scale(ctx, styles, one, relative_to, height, None),
+ [first, .., last] => {
+ scale(ctx, styles, first, relative_to, height, Some(MathClass::Opening));
+ scale(ctx, styles, last, relative_to, height, Some(MathClass::Closing));
+ }
+ _ => {}
+ }
+
+ // Handle MathFragment::Variant fragments that should be scaled up.
+ for fragment in &mut fragments {
+ if let MathFragment::Variant(ref mut variant) = fragment {
+ if variant.mid_stretched == Some(false) {
+ variant.mid_stretched = Some(true);
+ scale(ctx, styles, fragment, relative_to, height, Some(MathClass::Large));
+ }
+ }
+ }
+
+ // Remove weak SpacingFragment immediately after the opening or immediately
+ // before the closing.
+ let original_len = fragments.len();
+ let mut index = 0;
+ fragments.retain(|fragment| {
+ index += 1;
+ (index != 2 && index + 1 != original_len)
+ || !matches!(fragment, MathFragment::Spacing(_, true))
+ });
+
+ ctx.extend(fragments);
+
+ Ok(())
+}
+
+/// Lays out a [`MidElem`].
+#[typst_macros::time(name = "math.mid", span = elem.span())]
+pub fn layout_mid(
+ elem: &Packed<MidElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let mut fragments = ctx.layout_into_fragments(elem.body(), styles)?;
+
+ for fragment in &mut fragments {
+ match fragment {
+ MathFragment::Glyph(glyph) => {
+ let mut new = glyph.clone().into_variant();
+ new.mid_stretched = Some(false);
+ new.class = MathClass::Fence;
+ *fragment = MathFragment::Variant(new);
+ }
+ MathFragment::Variant(variant) => {
+ variant.mid_stretched = Some(false);
+ variant.class = MathClass::Fence;
+ }
+ _ => {}
+ }
+ }
+
+ ctx.extend(fragments);
+ Ok(())
+}
+
+/// Scale a math fragment to a height.
+fn scale(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ fragment: &mut MathFragment,
+ relative_to: Abs,
+ height: Smart<Rel<Length>>,
+ apply: Option<MathClass>,
+) {
+ if matches!(
+ fragment.class(),
+ MathClass::Opening | MathClass::Closing | MathClass::Fence
+ ) {
+ // This unwrap doesn't really matter. If it is None, then the fragment
+ // won't be stretchable anyways.
+ let short_fall = DELIM_SHORT_FALL.at(fragment.font_size().unwrap_or_default());
+ stretch_fragment(
+ ctx,
+ styles,
+ fragment,
+ Some(Axis::Y),
+ Some(relative_to),
+ height,
+ short_fall,
+ );
+
+ if let Some(class) = apply {
+ fragment.set_class(class);
+ }
+ }
+}
diff --git a/crates/typst-layout/src/math/mat.rs b/crates/typst-layout/src/math/mat.rs
new file mode 100644
index 00000000..6c8b0455
--- /dev/null
+++ b/crates/typst-layout/src/math/mat.rs
@@ -0,0 +1,333 @@
+use typst_library::diag::{bail, SourceResult};
+use typst_library::foundations::{Content, Packed, StyleChain};
+use typst_library::layout::{
+ Abs, Axes, Em, FixedAlignment, Frame, FrameItem, Point, Ratio, Rel, Size,
+};
+use typst_library::math::{Augment, AugmentOffsets, CasesElem, MatElem, VecElem};
+use typst_library::text::TextElem;
+use typst_library::visualize::{FillRule, FixedStroke, Geometry, LineCap, Shape};
+use typst_syntax::Span;
+
+use super::{
+ alignments, delimiter_alignment, scaled_font_size, stack, style_for_denominator,
+ AlignmentResult, FrameFragment, GlyphFragment, LeftRightAlternator, MathContext,
+ Scaled, DELIM_SHORT_FALL,
+};
+
+const VERTICAL_PADDING: Ratio = Ratio::new(0.1);
+const DEFAULT_STROKE_THICKNESS: Em = Em::new(0.05);
+
+/// Lays out a [`VecElem`].
+#[typst_macros::time(name = "math.vec", span = elem.span())]
+pub fn layout_vec(
+ elem: &Packed<VecElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let delim = elem.delim(styles);
+ let frame = layout_vec_body(
+ ctx,
+ styles,
+ elem.children(),
+ elem.align(styles),
+ elem.gap(styles).at(scaled_font_size(ctx, styles)),
+ LeftRightAlternator::Right,
+ )?;
+
+ layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), elem.span())
+}
+
+/// Lays out a [`MatElem`].
+#[typst_macros::time(name = "math.mat", span = elem.span())]
+pub fn layout_mat(
+ elem: &Packed<MatElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let augment = elem.augment(styles);
+ let rows = elem.rows();
+
+ if let Some(aug) = &augment {
+ for &offset in &aug.hline.0 {
+ if offset == 0 || offset.unsigned_abs() >= rows.len() {
+ bail!(
+ elem.span(),
+ "cannot draw a horizontal line after row {} of a matrix with {} rows",
+ if offset < 0 { rows.len() as isize + offset } else { offset },
+ rows.len()
+ );
+ }
+ }
+
+ let ncols = elem.rows().first().map_or(0, |row| row.len());
+
+ for &offset in &aug.vline.0 {
+ if offset == 0 || offset.unsigned_abs() >= ncols {
+ bail!(
+ elem.span(),
+ "cannot draw a vertical line after column {} of a matrix with {} columns",
+ if offset < 0 { ncols as isize + offset } else { offset },
+ ncols
+ );
+ }
+ }
+ }
+
+ let font_size = scaled_font_size(ctx, styles);
+ let column_gap = elem.column_gap(styles).at(font_size);
+ let row_gap = elem.row_gap(styles).at(font_size);
+ let delim = elem.delim(styles);
+ let frame = layout_mat_body(
+ ctx,
+ styles,
+ rows,
+ elem.align(styles),
+ augment,
+ Axes::new(column_gap, row_gap),
+ elem.span(),
+ )?;
+
+ layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), elem.span())
+}
+
+/// Lays out a [`CasesElem`].
+#[typst_macros::time(name = "math.cases", span = elem.span())]
+pub fn layout_cases(
+ elem: &Packed<CasesElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let delim = elem.delim(styles);
+ let frame = layout_vec_body(
+ ctx,
+ styles,
+ elem.children(),
+ FixedAlignment::Start,
+ elem.gap(styles).at(scaled_font_size(ctx, styles)),
+ LeftRightAlternator::None,
+ )?;
+
+ let (open, close) =
+ if elem.reverse(styles) { (None, delim.close()) } else { (delim.open(), None) };
+
+ layout_delimiters(ctx, styles, frame, open, close, elem.span())
+}
+
+/// Layout the inner contents of a vector.
+fn layout_vec_body(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ column: &[Content],
+ align: FixedAlignment,
+ row_gap: Rel<Abs>,
+ alternator: LeftRightAlternator,
+) -> SourceResult<Frame> {
+ let gap = row_gap.relative_to(ctx.region.size.y);
+
+ let denom_style = style_for_denominator(styles);
+ let mut flat = vec![];
+ for child in column {
+ flat.push(ctx.layout_into_run(child, styles.chain(&denom_style))?);
+ }
+ // We pad ascent and descent with the ascent and descent of the paren
+ // to ensure that normal vectors are aligned with others unless they are
+ // way too big.
+ let paren =
+ GlyphFragment::new(ctx, styles.chain(&denom_style), '(', Span::detached());
+ Ok(stack(flat, align, gap, 0, alternator, Some((paren.ascent, paren.descent))))
+}
+
+/// Layout the inner contents of a matrix.
+fn layout_mat_body(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ rows: &[Vec<Content>],
+ align: FixedAlignment,
+ augment: Option<Augment<Abs>>,
+ gap: Axes<Rel<Abs>>,
+ span: Span,
+) -> SourceResult<Frame> {
+ let ncols = rows.first().map_or(0, |row| row.len());
+ let nrows = rows.len();
+ if ncols == 0 || nrows == 0 {
+ return Ok(Frame::soft(Size::zero()));
+ }
+
+ let gap = gap.zip_map(ctx.region.size, Rel::relative_to);
+ let half_gap = gap * 0.5;
+
+ // We provide a default stroke thickness that scales
+ // 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 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(styles).as_decoration(),
+ cap: LineCap::Square,
+ ..Default::default()
+ };
+
+ let (hline, vline, stroke) = match augment {
+ Some(augment) => {
+ // We need to get stroke here for ownership.
+ let stroke = augment.stroke.unwrap_or_default().unwrap_or(default_stroke);
+ (augment.hline, augment.vline, stroke)
+ }
+ _ => (AugmentOffsets::default(), AugmentOffsets::default(), default_stroke),
+ };
+
+ // Before the full matrix body can be laid out, the
+ // individual cells must first be independently laid out
+ // so we can ensure alignment across rows and columns.
+
+ // This variable stores the maximum ascent and descent for each row.
+ let mut heights = vec![(Abs::zero(), Abs::zero()); nrows];
+
+ // We want to transpose our data layout to columns
+ // before final layout. For efficiency, the columns
+ // variable is set up here and newly generated
+ // individual cells are then added to it.
+ let mut cols = vec![vec![]; ncols];
+
+ let denom_style = style_for_denominator(styles);
+ // We pad ascent and descent with the ascent and descent of the paren
+ // to ensure that normal matrices are aligned with others unless they are
+ // way too big.
+ let paren =
+ GlyphFragment::new(ctx, styles.chain(&denom_style), '(', Span::detached());
+
+ for (row, (ascent, descent)) in rows.iter().zip(&mut heights) {
+ for (cell, col) in row.iter().zip(&mut cols) {
+ let cell = ctx.layout_into_run(cell, styles.chain(&denom_style))?;
+
+ ascent.set_max(cell.ascent().max(paren.ascent));
+ descent.set_max(cell.descent().max(paren.descent));
+
+ col.push(cell);
+ }
+ }
+
+ // 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.
+ let total_height =
+ heights.iter().map(|&(a, b)| a + b).sum::<Abs>() + gap.y * (nrows - 1) as f64;
+
+ // Width starts at zero because it can't be calculated until later
+ let mut frame = Frame::soft(Size::new(Abs::zero(), total_height));
+
+ let mut x = Abs::zero();
+
+ for (index, col) in cols.into_iter().enumerate() {
+ let AlignmentResult { points, width: rcol } = alignments(&col);
+
+ let mut y = Abs::zero();
+
+ for (cell, &(ascent, descent)) in col.into_iter().zip(&heights) {
+ let cell = cell.into_line_frame(&points, LeftRightAlternator::Right);
+ let pos = Point::new(
+ if points.is_empty() {
+ x + align.position(rcol - cell.width())
+ } else {
+ x
+ },
+ y + ascent - cell.ascent(),
+ );
+
+ frame.push_frame(pos, cell);
+
+ y += ascent + descent + gap.y;
+ }
+
+ // Advance to the end of the column
+ x += rcol;
+
+ // If a vertical line should be inserted after this column
+ if vline.0.contains(&(index as isize + 1))
+ || vline.0.contains(&(1 - ((ncols - index) as isize)))
+ {
+ frame.push(
+ Point::with_x(x + half_gap.x),
+ line_item(total_height, true, stroke.clone(), span),
+ );
+ }
+
+ // Advance to the start of the next column
+ x += gap.x;
+ }
+
+ // Once all the columns are laid out, the total width can be calculated
+ let total_width = x - gap.x;
+
+ // This allows the horizontal lines to be laid out
+ for line in hline.0 {
+ let real_line =
+ if line < 0 { nrows - line.unsigned_abs() } else { line as usize };
+ let offset = (heights[0..real_line].iter().map(|&(a, b)| a + b).sum::<Abs>()
+ + gap.y * (real_line - 1) as f64)
+ + half_gap.y;
+
+ frame.push(
+ Point::with_y(offset),
+ line_item(total_width, false, stroke.clone(), span),
+ );
+ }
+
+ frame.size_mut().x = total_width;
+
+ Ok(frame)
+}
+
+fn line_item(length: Abs, vertical: bool, stroke: FixedStroke, span: Span) -> FrameItem {
+ let line_geom = if vertical {
+ Geometry::Line(Point::with_y(length))
+ } else {
+ Geometry::Line(Point::with_x(length))
+ };
+
+ FrameItem::Shape(
+ Shape {
+ geometry: line_geom,
+ fill: None,
+ fill_rule: FillRule::default(),
+ stroke: Some(stroke),
+ },
+ span,
+ )
+}
+
+/// 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 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, styles, left, span)
+ .stretch_vertical(ctx, target, short_fall);
+ left.align_on_axis(ctx, delimiter_alignment(left.c));
+ ctx.push(left);
+ }
+
+ ctx.push(FrameFragment::new(ctx, styles, frame));
+
+ if let Some(right) = right {
+ let mut right = GlyphFragment::new(ctx, styles, right, span)
+ .stretch_vertical(ctx, target, short_fall);
+ right.align_on_axis(ctx, delimiter_alignment(right.c));
+ ctx.push(right);
+ }
+
+ Ok(())
+}
diff --git a/crates/typst-layout/src/math/mod.rs b/crates/typst-layout/src/math/mod.rs
new file mode 100644
index 00000000..b3dde977
--- /dev/null
+++ b/crates/typst-layout/src/math/mod.rs
@@ -0,0 +1,703 @@
+#[macro_use]
+mod shared;
+mod accent;
+mod attach;
+mod cancel;
+mod frac;
+mod fragment;
+mod lr;
+mod mat;
+mod root;
+mod run;
+mod stretch;
+mod text;
+mod underover;
+
+use ttf_parser::gsub::SubstitutionSubtable;
+use typst_library::diag::{bail, SourceResult};
+use typst_library::engine::Engine;
+use typst_library::foundations::{Content, NativeElement, Packed, Resolve, StyleChain};
+use typst_library::introspection::{Counter, Locator, SplitLocator, TagElem};
+use typst_library::layout::{
+ Abs, AlignElem, Axes, BlockElem, BoxElem, Em, FixedAlignment, Fragment, Frame, HElem,
+ InlineItem, OuterHAlignment, PlaceElem, Point, Region, Regions, Size, Spacing,
+ SpecificAlignment, VAlignment,
+};
+use typst_library::math::*;
+use typst_library::model::ParElem;
+use typst_library::routines::{Arenas, RealizationKind};
+use typst_library::text::{
+ families, features, variant, Font, LinebreakElem, SpaceElem, TextEdgeBounds,
+ TextElem, TextSize,
+};
+use typst_library::World;
+use typst_syntax::Span;
+use typst_utils::Numeric;
+use unicode_math_class::MathClass;
+
+use self::fragment::{
+ FrameFragment, GlyphFragment, GlyphwiseSubsts, Limits, MathFragment, VariantFragment,
+};
+use self::run::{LeftRightAlternator, MathRun, MathRunFrameBuilder};
+use self::shared::*;
+use self::stretch::{stretch_fragment, stretch_glyph};
+
+/// Layout an inline equation (in a paragraph).
+#[typst_macros::time(span = elem.span())]
+pub fn layout_equation_inline(
+ elem: &Packed<EquationElem>,
+ engine: &mut Engine,
+ locator: Locator,
+ styles: StyleChain,
+ region: Size,
+) -> SourceResult<Vec<InlineItem>> {
+ assert!(!elem.block(styles));
+
+ let font = find_math_font(engine, styles, elem.span())?;
+
+ let mut locator = locator.split();
+ let mut ctx = MathContext::new(engine, &mut locator, styles, region, &font);
+ let run = ctx.layout_into_run(&elem.body, styles)?;
+
+ let mut items = if run.row_count() == 1 {
+ run.into_par_items()
+ } else {
+ vec![InlineItem::Frame(run.into_fragment(&ctx, styles).into_frame())]
+ };
+
+ // An empty equation should have a height, so we still create a frame
+ // (which is then resized in the loop).
+ if items.is_empty() {
+ items.push(InlineItem::Frame(Frame::soft(Size::zero())));
+ }
+
+ for item in &mut items {
+ let InlineItem::Frame(frame) = item else { continue };
+
+ let font_size = scaled_font_size(&ctx, styles);
+ let slack = ParElem::leading_in(styles) * 0.7;
+
+ let (t, b) = font.edges(
+ TextElem::top_edge_in(styles),
+ TextElem::bottom_edge_in(styles),
+ font_size,
+ TextEdgeBounds::Frame(frame),
+ );
+
+ let ascent = t.max(frame.ascent() - slack);
+ let descent = b.max(frame.descent() - slack);
+ frame.translate(Point::with_y(ascent - frame.baseline()));
+ frame.size_mut().y = ascent + descent;
+ }
+
+ Ok(items)
+}
+
+/// Layout a block-level equation (in a flow).
+#[typst_macros::time(span = elem.span())]
+pub fn layout_equation_block(
+ elem: &Packed<EquationElem>,
+ engine: &mut Engine,
+ locator: Locator,
+ styles: StyleChain,
+ regions: Regions,
+) -> SourceResult<Fragment> {
+ assert!(elem.block(styles));
+
+ let span = elem.span();
+ let font = find_math_font(engine, styles, span)?;
+
+ let mut locator = locator.split();
+ let mut ctx = MathContext::new(engine, &mut locator, styles, regions.base(), &font);
+ let full_equation_builder = ctx
+ .layout_into_run(&elem.body, styles)?
+ .multiline_frame_builder(&ctx, styles);
+ let width = full_equation_builder.size.x;
+
+ let equation_builders = if BlockElem::breakable_in(styles) {
+ let mut rows = full_equation_builder.frames.into_iter().peekable();
+ let mut equation_builders = vec![];
+ let mut last_first_pos = Point::zero();
+ let mut regions = regions;
+
+ loop {
+ // Keep track of the position of the first row in this region,
+ // so that the offset can be reverted later.
+ let Some(&(_, first_pos)) = rows.peek() else { break };
+ last_first_pos = first_pos;
+
+ let mut frames = vec![];
+ let mut height = Abs::zero();
+ while let Some((sub, pos)) = rows.peek() {
+ let mut pos = *pos;
+ pos.y -= first_pos.y;
+
+ // Finish this region if the line doesn't fit. Only do it if
+ // we placed at least one line _or_ we still have non-last
+ // regions. Crucially, we don't want to infinitely create
+ // new regions which are too small.
+ if !regions.size.y.fits(sub.height() + pos.y)
+ && (regions.may_progress()
+ || (regions.may_break() && !frames.is_empty()))
+ {
+ break;
+ }
+
+ let (sub, _) = rows.next().unwrap();
+ height = height.max(pos.y + sub.height());
+ frames.push((sub, pos));
+ }
+
+ equation_builders
+ .push(MathRunFrameBuilder { frames, size: Size::new(width, height) });
+ regions.next();
+ }
+
+ // Append remaining rows to the equation builder of the last region.
+ if let Some(equation_builder) = equation_builders.last_mut() {
+ equation_builder.frames.extend(rows.map(|(frame, mut pos)| {
+ pos.y -= last_first_pos.y;
+ (frame, pos)
+ }));
+
+ let height = equation_builder
+ .frames
+ .iter()
+ .map(|(frame, pos)| frame.height() + pos.y)
+ .max()
+ .unwrap_or(equation_builder.size.y);
+
+ equation_builder.size.y = height;
+ }
+
+ // Ensure that there is at least one frame, even for empty equations.
+ if equation_builders.is_empty() {
+ equation_builders
+ .push(MathRunFrameBuilder { frames: vec![], size: Size::zero() });
+ }
+
+ equation_builders
+ } else {
+ vec![full_equation_builder]
+ };
+
+ let Some(numbering) = (**elem).numbering(styles) else {
+ let frames = equation_builders
+ .into_iter()
+ .map(MathRunFrameBuilder::build)
+ .collect();
+ return Ok(Fragment::frames(frames));
+ };
+
+ let pod = Region::new(regions.base(), Axes::splat(false));
+ let counter = Counter::of(EquationElem::elem())
+ .display_at_loc(engine, elem.location().unwrap(), styles, numbering)?
+ .spanned(span);
+ let number =
+ (engine.routines.layout_frame)(engine, &counter, locator.next(&()), styles, pod)?;
+
+ static NUMBER_GUTTER: Em = Em::new(0.5);
+ let full_number_width = number.width() + NUMBER_GUTTER.resolve(styles);
+
+ let number_align = match elem.number_align(styles) {
+ SpecificAlignment::H(h) => SpecificAlignment::Both(h, VAlignment::Horizon),
+ SpecificAlignment::V(v) => SpecificAlignment::Both(OuterHAlignment::End, v),
+ SpecificAlignment::Both(h, v) => SpecificAlignment::Both(h, v),
+ };
+
+ // Add equation numbers to each equation region.
+ let region_count = equation_builders.len();
+ let frames = equation_builders
+ .into_iter()
+ .map(|builder| {
+ if builder.frames.is_empty() && region_count > 1 {
+ // Don't number empty regions, but do number empty equations.
+ return builder.build();
+ }
+ add_equation_number(
+ builder,
+ number.clone(),
+ number_align.resolve(styles),
+ AlignElem::alignment_in(styles).resolve(styles).x,
+ regions.size.x,
+ full_number_width,
+ )
+ })
+ .collect();
+
+ Ok(Fragment::frames(frames))
+}
+
+fn find_math_font(
+ engine: &mut Engine<'_>,
+ styles: StyleChain,
+ span: Span,
+) -> SourceResult<Font> {
+ let variant = variant(styles);
+ let world = engine.world;
+ let Some(font) = families(styles).find_map(|family| {
+ let id = world.book().select(family, variant)?;
+ let font = world.font(id)?;
+ let _ = font.ttf().tables().math?.constants?;
+ Some(font)
+ }) else {
+ bail!(span, "current font does not support math");
+ };
+ Ok(font)
+}
+
+fn add_equation_number(
+ equation_builder: MathRunFrameBuilder,
+ number: Frame,
+ number_align: Axes<FixedAlignment>,
+ equation_align: FixedAlignment,
+ region_size_x: Abs,
+ full_number_width: Abs,
+) -> Frame {
+ let first =
+ equation_builder.frames.first().map_or(
+ (equation_builder.size, Point::zero(), Abs::zero()),
+ |(frame, pos)| (frame.size(), *pos, frame.baseline()),
+ );
+ let last =
+ equation_builder.frames.last().map_or(
+ (equation_builder.size, Point::zero(), Abs::zero()),
+ |(frame, pos)| (frame.size(), *pos, frame.baseline()),
+ );
+ let line_count = equation_builder.frames.len();
+ let mut equation = equation_builder.build();
+
+ let width = if region_size_x.is_finite() {
+ region_size_x
+ } else {
+ equation.width() + 2.0 * full_number_width
+ };
+
+ let is_multiline = line_count >= 2;
+ let resizing_offset = resize_equation(
+ &mut equation,
+ &number,
+ number_align,
+ equation_align,
+ width,
+ is_multiline,
+ [first, last],
+ );
+ equation.translate(Point::with_x(match (equation_align, number_align.x) {
+ (FixedAlignment::Start, FixedAlignment::Start) => full_number_width,
+ (FixedAlignment::End, FixedAlignment::End) => -full_number_width,
+ _ => Abs::zero(),
+ }));
+
+ let x = match number_align.x {
+ FixedAlignment::Start => Abs::zero(),
+ FixedAlignment::End => equation.width() - number.width(),
+ _ => unreachable!(),
+ };
+ let y = {
+ let align_baselines = |(_, pos, baseline): (_, Point, Abs), number: &Frame| {
+ resizing_offset.y + pos.y + baseline - number.baseline()
+ };
+ match number_align.y {
+ FixedAlignment::Start => align_baselines(first, &number),
+ FixedAlignment::Center if !is_multiline => align_baselines(first, &number),
+ // In this case, the center lines (not baselines) of the number frame
+ // and the equation frame shall be aligned.
+ FixedAlignment::Center => (equation.height() - number.height()) / 2.0,
+ FixedAlignment::End => align_baselines(last, &number),
+ }
+ };
+
+ equation.push_frame(Point::new(x, y), number);
+ equation
+}
+
+/// Resize the equation's frame accordingly so that it encompasses the number.
+fn resize_equation(
+ equation: &mut Frame,
+ number: &Frame,
+ number_align: Axes<FixedAlignment>,
+ equation_align: FixedAlignment,
+ width: Abs,
+ is_multiline: bool,
+ [first, last]: [(Axes<Abs>, Point, Abs); 2],
+) -> Point {
+ if matches!(number_align.y, FixedAlignment::Center if is_multiline) {
+ // In this case, the center lines (not baselines) of the number frame
+ // and the equation frame shall be aligned.
+ return equation.resize(
+ Size::new(width, equation.height().max(number.height())),
+ Axes::<FixedAlignment>::new(equation_align, FixedAlignment::Center),
+ );
+ }
+
+ let excess_above = Abs::zero().max({
+ if !is_multiline || matches!(number_align.y, FixedAlignment::Start) {
+ let (.., baseline) = first;
+ number.baseline() - baseline
+ } else {
+ Abs::zero()
+ }
+ });
+ let excess_below = Abs::zero().max({
+ if !is_multiline || matches!(number_align.y, FixedAlignment::End) {
+ let (size, .., baseline) = last;
+ (number.height() - number.baseline()) - (size.y - baseline)
+ } else {
+ Abs::zero()
+ }
+ });
+
+ // The vertical expansion is asymmetric on the top and bottom edges, so we
+ // first align at the top then translate the content downward later.
+ let resizing_offset = equation.resize(
+ Size::new(width, equation.height() + excess_above + excess_below),
+ Axes::<FixedAlignment>::new(equation_align, FixedAlignment::Start),
+ );
+ equation.translate(Point::with_y(excess_above));
+ resizing_offset + Point::with_y(excess_above)
+}
+
+/// The context for math layout.
+struct MathContext<'a, 'v, 'e> {
+ // External.
+ engine: &'v mut Engine<'e>,
+ locator: &'v mut SplitLocator<'a>,
+ region: Region,
+ // Font-related.
+ font: &'a Font,
+ ttf: &'a ttf_parser::Face<'a>,
+ table: ttf_parser::math::Table<'a>,
+ constants: ttf_parser::math::Constants<'a>,
+ ssty_table: Option<ttf_parser::gsub::AlternateSubstitution<'a>>,
+ glyphwise_tables: Option<Vec<GlyphwiseSubsts<'a>>>,
+ space_width: Em,
+ // Mutable.
+ fragments: Vec<MathFragment>,
+}
+
+impl<'a, 'v, 'e> MathContext<'a, 'v, 'e> {
+ /// Create a new math context.
+ fn new(
+ engine: &'v mut Engine<'e>,
+ locator: &'v mut SplitLocator<'a>,
+ styles: StyleChain<'a>,
+ base: Size,
+ font: &'a Font,
+ ) -> Self {
+ let math_table = font.ttf().tables().math.unwrap();
+ let gsub_table = font.ttf().tables().gsub;
+ let constants = math_table.constants.unwrap();
+
+ let ssty_table = gsub_table
+ .and_then(|gsub| {
+ gsub.features
+ .find(ttf_parser::Tag::from_bytes(b"ssty"))
+ .and_then(|feature| feature.lookup_indices.get(0))
+ .and_then(|index| gsub.lookups.get(index))
+ })
+ .and_then(|ssty| ssty.subtables.get::<SubstitutionSubtable>(0))
+ .and_then(|ssty| match ssty {
+ SubstitutionSubtable::Alternate(alt_glyphs) => Some(alt_glyphs),
+ _ => None,
+ });
+
+ let features = features(styles);
+ let glyphwise_tables = gsub_table.map(|gsub| {
+ features
+ .into_iter()
+ .filter_map(|feature| GlyphwiseSubsts::new(gsub, feature))
+ .collect()
+ });
+
+ let ttf = font.ttf();
+ let space_width = ttf
+ .glyph_index(' ')
+ .and_then(|id| ttf.glyph_hor_advance(id))
+ .map(|advance| font.to_em(advance))
+ .unwrap_or(THICK);
+
+ Self {
+ engine,
+ locator,
+ region: Region::new(base, Axes::splat(false)),
+ font,
+ ttf: font.ttf(),
+ table: math_table,
+ constants,
+ ssty_table,
+ glyphwise_tables,
+ space_width,
+ fragments: vec![],
+ }
+ }
+
+ /// Push a fragment.
+ fn push(&mut self, fragment: impl Into<MathFragment>) {
+ self.fragments.push(fragment.into());
+ }
+
+ /// Push multiple fragments.
+ fn extend(&mut self, fragments: impl IntoIterator<Item = MathFragment>) {
+ self.fragments.extend(fragments);
+ }
+
+ /// Layout the given element and return the result as a [`MathRun`].
+ fn layout_into_run(
+ &mut self,
+ elem: &Content,
+ styles: StyleChain,
+ ) -> SourceResult<MathRun> {
+ Ok(MathRun::new(self.layout_into_fragments(elem, styles)?))
+ }
+
+ /// Layout the given element and return the resulting [`MathFragment`]s.
+ fn layout_into_fragments(
+ &mut self,
+ elem: &Content,
+ styles: StyleChain,
+ ) -> SourceResult<Vec<MathFragment>> {
+ // The element's layout_math() changes the fragments held in this
+ // MathContext object, but for convenience this function shouldn't change
+ // them, so we restore the MathContext's fragments after obtaining the
+ // layout result.
+ let prev = std::mem::take(&mut self.fragments);
+ self.layout_into_self(elem, styles)?;
+ Ok(std::mem::replace(&mut self.fragments, prev))
+ }
+
+ /// Layout the given element and return the result as a
+ /// unified [`MathFragment`].
+ fn layout_into_fragment(
+ &mut self,
+ elem: &Content,
+ styles: StyleChain,
+ ) -> SourceResult<MathFragment> {
+ Ok(self.layout_into_run(elem, styles)?.into_fragment(self, styles))
+ }
+
+ /// Layout the given element and return the result as a [`Frame`].
+ fn layout_into_frame(
+ &mut self,
+ elem: &Content,
+ styles: StyleChain,
+ ) -> SourceResult<Frame> {
+ Ok(self.layout_into_fragment(elem, styles)?.into_frame())
+ }
+
+ /// Layout arbitrary content.
+ fn layout_into_self(
+ &mut self,
+ content: &Content,
+ styles: StyleChain,
+ ) -> SourceResult<()> {
+ let arenas = Arenas::default();
+ let pairs = (self.engine.routines.realize)(
+ RealizationKind::Math,
+ self.engine,
+ self.locator,
+ &arenas,
+ content,
+ styles,
+ )?;
+
+ let outer = styles;
+ for (elem, styles) in pairs {
+ // Hack because the font is fixed in math.
+ if styles != outer && TextElem::font_in(styles) != TextElem::font_in(outer) {
+ let frame = layout_external(elem, self, styles)?;
+ self.push(FrameFragment::new(self, styles, frame).with_spaced(true));
+ continue;
+ }
+
+ layout_realized(elem, self, styles)?;
+ }
+
+ Ok(())
+ }
+}
+
+/// Lays out a leaf element resulting from realization.
+fn layout_realized(
+ elem: &Content,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ if let Some(elem) = elem.to_packed::<TagElem>() {
+ ctx.push(MathFragment::Tag(elem.tag.clone()));
+ } else if elem.is::<SpaceElem>() {
+ let font_size = scaled_font_size(ctx, styles);
+ ctx.push(MathFragment::Space(ctx.space_width.at(font_size)));
+ } else if elem.is::<LinebreakElem>() {
+ ctx.push(MathFragment::Linebreak);
+ } else if let Some(elem) = elem.to_packed::<HElem>() {
+ layout_h(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<TextElem>() {
+ self::text::layout_text(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<BoxElem>() {
+ layout_box(elem, ctx, styles)?;
+ } else if elem.is::<AlignPointElem>() {
+ ctx.push(MathFragment::Align);
+ } else if let Some(elem) = elem.to_packed::<ClassElem>() {
+ layout_class(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<AccentElem>() {
+ self::accent::layout_accent(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<AttachElem>() {
+ self::attach::layout_attach(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<PrimesElem>() {
+ self::attach::layout_primes(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<ScriptsElem>() {
+ self::attach::layout_scripts(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<LimitsElem>() {
+ self::attach::layout_limits(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<CancelElem>() {
+ self::cancel::layout_cancel(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<FracElem>() {
+ self::frac::layout_frac(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<BinomElem>() {
+ self::frac::layout_binom(elem, ctx, styles)?;
+ } else if let Some(elem) = elem.to_packed::<LrElem>() {
+ self::lr::layout_lr(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<MidElem>() {
+ self::lr::layout_mid(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<VecElem>() {
+ self::mat::layout_vec(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<MatElem>() {
+ self::mat::layout_mat(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<CasesElem>() {
+ self::mat::layout_cases(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<OpElem>() {
+ layout_op(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<RootElem>() {
+ self::root::layout_root(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<StretchElem>() {
+ self::stretch::layout_stretch(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<UnderlineElem>() {
+ self::underover::layout_underline(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<OverlineElem>() {
+ self::underover::layout_overline(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<UnderbraceElem>() {
+ self::underover::layout_underbrace(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<OverbraceElem>() {
+ self::underover::layout_overbrace(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<UnderbracketElem>() {
+ self::underover::layout_underbracket(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<OverbracketElem>() {
+ self::underover::layout_overbracket(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<UnderparenElem>() {
+ self::underover::layout_underparen(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<OverparenElem>() {
+ self::underover::layout_overparen(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<UndershellElem>() {
+ self::underover::layout_undershell(elem, ctx, styles)?
+ } else if let Some(elem) = elem.to_packed::<OvershellElem>() {
+ self::underover::layout_overshell(elem, ctx, styles)?
+ } else {
+ let mut frame = layout_external(elem, ctx, styles)?;
+ if !frame.has_baseline() {
+ let axis = scaled!(ctx, styles, axis_height);
+ frame.set_baseline(frame.height() / 2.0 + axis);
+ }
+ ctx.push(
+ FrameFragment::new(ctx, styles, frame)
+ .with_spaced(true)
+ .with_ignorant(elem.is::<PlaceElem>()),
+ );
+ }
+
+ Ok(())
+}
+
+/// Lays out an [`BoxElem`].
+fn layout_box(
+ elem: &Packed<BoxElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let local = TextElem::set_size(TextSize(scaled_font_size(ctx, styles).into())).wrap();
+ let frame = (ctx.engine.routines.layout_box)(
+ elem,
+ ctx.engine,
+ ctx.locator.next(&elem.span()),
+ styles.chain(&local),
+ ctx.region.size,
+ )?;
+ ctx.push(FrameFragment::new(ctx, styles, frame).with_spaced(true));
+ Ok(())
+}
+
+/// Lays out an [`HElem`].
+fn layout_h(
+ elem: &Packed<HElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ if let Spacing::Rel(rel) = elem.amount() {
+ if rel.rel.is_zero() {
+ ctx.push(MathFragment::Spacing(
+ rel.abs.at(scaled_font_size(ctx, styles)),
+ elem.weak(styles),
+ ));
+ }
+ }
+ Ok(())
+}
+
+/// Lays out a [`ClassElem`].
+#[typst_macros::time(name = "math.op", span = elem.span())]
+fn layout_class(
+ elem: &Packed<ClassElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let class = *elem.class();
+ let style = EquationElem::set_class(Some(class)).wrap();
+ let mut fragment = ctx.layout_into_fragment(elem.body(), styles.chain(&style))?;
+ fragment.set_class(class);
+ fragment.set_limits(Limits::for_class(class));
+ ctx.push(fragment);
+ Ok(())
+}
+
+/// Lays out an [`OpElem`].
+#[typst_macros::time(name = "math.op", span = elem.span())]
+fn layout_op(
+ elem: &Packed<OpElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let fragment = ctx.layout_into_fragment(elem.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, 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 elem.limits(styles) {
+ Limits::Display
+ } else {
+ Limits::Never
+ }),
+ );
+ Ok(())
+}
+
+/// Layout into a frame with normal layout.
+fn layout_external(
+ content: &Content,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<Frame> {
+ let local = TextElem::set_size(TextSize(scaled_font_size(ctx, styles).into())).wrap();
+ (ctx.engine.routines.layout_frame)(
+ ctx.engine,
+ content,
+ ctx.locator.next(&content.span()),
+ styles.chain(&local),
+ ctx.region,
+ )
+}
diff --git a/crates/typst-layout/src/math/root.rs b/crates/typst-layout/src/math/root.rs
new file mode 100644
index 00000000..0bb2f539
--- /dev/null
+++ b/crates/typst-layout/src/math/root.rs
@@ -0,0 +1,126 @@
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Packed, StyleChain};
+use typst_library::layout::{Abs, Frame, FrameItem, Point, Size};
+use typst_library::math::{EquationElem, MathSize, RootElem};
+use typst_library::text::TextElem;
+use typst_library::visualize::{FixedStroke, Geometry};
+
+use super::{style_cramped, FrameFragment, GlyphFragment, MathContext};
+
+/// Lays out a [`RootElem`].
+///
+/// TeXbook page 443, page 360
+/// See also: <https://www.w3.org/TR/mathml-core/#radicals-msqrt-mroot>
+#[typst_macros::time(name = "math.root", span = elem.span())]
+pub fn layout_root(
+ elem: &Packed<RootElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let index = elem.index(styles);
+ let radicand = elem.radicand();
+ let span = elem.span();
+
+ let gap = scaled!(
+ ctx, styles,
+ text: radical_vertical_gap,
+ display: radical_display_style_vertical_gap,
+ );
+ 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.
+ let radicand = {
+ let cramped = style_cramped();
+ let styles = styles.chain(&cramped);
+ let run = ctx.layout_into_run(radicand, styles)?;
+ let multiline = run.is_multiline();
+ let mut radicand = run.into_fragment(ctx, styles).into_frame();
+ if multiline {
+ // Align the frame center line with the math axis.
+ radicand.set_baseline(
+ radicand.height() / 2.0 + scaled!(ctx, styles, axis_height),
+ );
+ }
+ radicand
+ };
+
+ // Layout root symbol.
+ let target = radicand.height() + thickness + gap;
+ let sqrt = GlyphFragment::new(ctx, styles, '√', span)
+ .stretch_vertical(ctx, target, Abs::zero())
+ .frame;
+
+ // Layout the index.
+ let sscript = EquationElem::set_size(MathSize::ScriptScript).wrap();
+ let index = index
+ .as_ref()
+ .map(|elem| ctx.layout_into_frame(elem, styles.chain(&sscript)))
+ .transpose()?;
+
+ // TeXbook, page 443, item 11
+ // Keep original gap, and then distribute any remaining free space
+ // equally above and below.
+ let gap = gap.max((sqrt.height() - thickness - radicand.height() + gap) / 2.0);
+
+ let sqrt_ascent = radicand.ascent() + gap + thickness;
+ let descent = sqrt.height() - sqrt_ascent;
+ let inner_ascent = sqrt_ascent + extra_ascender;
+
+ let mut sqrt_offset = Abs::zero();
+ let mut shift_up = Abs::zero();
+ let mut ascent = inner_ascent;
+
+ if let Some(index) = &index {
+ sqrt_offset = kern_before + index.width() + kern_after;
+ // The formula below for how much raise the index by comes from
+ // the TeXbook, page 360, in the definition of `\root`.
+ // However, the `+ index.descent()` part is different from TeX.
+ // Without it, descenders can collide with the surd, a rarity
+ // in practice, but possible. MS Word also adjusts index positions
+ // for descenders.
+ shift_up = raise_factor * (inner_ascent - descent) + index.descent();
+ ascent.set_max(shift_up + index.ascent());
+ }
+
+ let radicand_x = sqrt_offset + sqrt.width();
+ let radicand_y = ascent - radicand.ascent();
+ let width = radicand_x + radicand.width();
+ let size = Size::new(width, ascent + descent);
+
+ // The extra "- thickness" comes from the fact that the sqrt is placed
+ // in `push_frame` with respect to its top, not its baseline.
+ let sqrt_pos = Point::new(sqrt_offset, radicand_y - gap - thickness);
+ let line_pos = Point::new(radicand_x, radicand_y - gap - (thickness / 2.0));
+ let radicand_pos = Point::new(radicand_x, radicand_y);
+
+ let mut frame = Frame::soft(size);
+ frame.set_baseline(ascent);
+
+ if let Some(index) = index {
+ let index_pos = Point::new(kern_before, ascent - index.ascent() - shift_up);
+ frame.push_frame(index_pos, index);
+ }
+
+ frame.push_frame(sqrt_pos, sqrt);
+ frame.push(
+ line_pos,
+ FrameItem::Shape(
+ Geometry::Line(Point::with_x(radicand.width())).stroked(
+ FixedStroke::from_pair(
+ TextElem::fill_in(styles).as_decoration(),
+ thickness,
+ ),
+ ),
+ span,
+ ),
+ );
+
+ frame.push_frame(radicand_pos, radicand);
+ ctx.push(FrameFragment::new(ctx, styles, frame));
+
+ Ok(())
+}
diff --git a/crates/typst-layout/src/math/run.rs b/crates/typst-layout/src/math/run.rs
new file mode 100644
index 00000000..8f12c509
--- /dev/null
+++ b/crates/typst-layout/src/math/run.rs
@@ -0,0 +1,469 @@
+use std::iter::once;
+
+use typst_library::foundations::{Resolve, StyleChain};
+use typst_library::layout::{Abs, AlignElem, Em, Frame, InlineItem, Point, Size};
+use typst_library::math::{EquationElem, MathSize, MEDIUM, THICK, THIN};
+use typst_library::model::ParElem;
+use unicode_math_class::MathClass;
+
+use super::{alignments, scaled_font_size, FrameFragment, MathContext, MathFragment};
+
+const TIGHT_LEADING: Em = Em::new(0.25);
+
+/// A linear collection of [`MathFragment`]s.
+#[derive(Debug, Default, Clone)]
+pub struct MathRun(Vec<MathFragment>);
+
+impl MathRun {
+ /// Takes the given [`MathFragment`]s and do some basic processing.
+ pub fn new(fragments: Vec<MathFragment>) -> Self {
+ let iter = fragments.into_iter().peekable();
+ let mut last: Option<usize> = None;
+ let mut space: Option<MathFragment> = None;
+ let mut resolved: Vec<MathFragment> = vec![];
+
+ for mut fragment in iter {
+ match fragment {
+ // Keep space only if supported by spaced fragments.
+ MathFragment::Space(_) => {
+ if last.is_some() {
+ space = Some(fragment);
+ }
+ continue;
+ }
+
+ // Explicit spacing disables automatic spacing.
+ MathFragment::Spacing(width, weak) => {
+ last = None;
+ space = None;
+
+ if weak {
+ match resolved.last_mut() {
+ None => continue,
+ Some(MathFragment::Spacing(prev, true)) => {
+ *prev = (*prev).max(width);
+ continue;
+ }
+ Some(_) => {}
+ }
+ }
+
+ resolved.push(fragment);
+ continue;
+ }
+
+ // Alignment points are resolved later.
+ MathFragment::Align => {
+ resolved.push(fragment);
+ continue;
+ }
+
+ // New line, new things.
+ MathFragment::Linebreak => {
+ resolved.push(fragment);
+ space = None;
+ last = None;
+ continue;
+ }
+
+ _ => {}
+ }
+
+ // Convert variable operators into binary operators if something
+ // precedes them and they are not preceded by a operator or comparator.
+ if fragment.class() == MathClass::Vary
+ && matches!(
+ last.map(|i| resolved[i].class()),
+ Some(
+ MathClass::Normal
+ | MathClass::Alphabetic
+ | MathClass::Closing
+ | MathClass::Fence
+ )
+ )
+ {
+ fragment.set_class(MathClass::Binary);
+ }
+
+ // Insert spacing between the last and this non-ignorant item.
+ if !fragment.is_ignorant() {
+ if let Some(i) = last {
+ if let Some(s) = spacing(&resolved[i], space.take(), &fragment) {
+ resolved.insert(i + 1, s);
+ }
+ }
+
+ last = Some(resolved.len());
+ }
+
+ resolved.push(fragment);
+ }
+
+ if let Some(MathFragment::Spacing(_, true)) = resolved.last() {
+ resolved.pop();
+ }
+
+ Self(resolved)
+ }
+
+ pub fn iter(&self) -> std::slice::Iter<'_, MathFragment> {
+ self.0.iter()
+ }
+
+ /// Split by linebreaks, and copy [`MathFragment`]s into rows.
+ pub fn rows(&self) -> Vec<Self> {
+ self.0
+ .split(|frag| matches!(frag, MathFragment::Linebreak))
+ .map(|slice| Self(slice.to_vec()))
+ .collect()
+ }
+
+ pub fn row_count(&self) -> usize {
+ let mut count =
+ 1 + self.0.iter().filter(|f| matches!(f, MathFragment::Linebreak)).count();
+
+ // A linebreak at the very end does not introduce an extra row.
+ if let Some(f) = self.0.last() {
+ if matches!(f, MathFragment::Linebreak) {
+ count -= 1
+ }
+ }
+ count
+ }
+
+ pub fn ascent(&self) -> Abs {
+ self.iter()
+ .filter(|e| affects_row_height(e))
+ .map(|e| e.ascent())
+ .max()
+ .unwrap_or_default()
+ }
+
+ pub fn descent(&self) -> Abs {
+ self.iter()
+ .filter(|e| affects_row_height(e))
+ .map(|e| e.descent())
+ .max()
+ .unwrap_or_default()
+ }
+
+ pub fn class(&self) -> MathClass {
+ // Predict the class of the output of 'into_fragment'
+ if self.0.len() == 1 {
+ self.0
+ .first()
+ .map(|fragment| fragment.class())
+ .unwrap_or(MathClass::Normal)
+ } else {
+ // FrameFragment::new() (inside 'into_fragment' in this branch) defaults
+ // to MathClass::Normal for its class.
+ MathClass::Normal
+ }
+ }
+
+ pub fn into_frame(self, ctx: &MathContext, styles: StyleChain) -> Frame {
+ if !self.is_multiline() {
+ self.into_line_frame(&[], LeftRightAlternator::Right)
+ } else {
+ self.multiline_frame_builder(ctx, styles).build()
+ }
+ }
+
+ pub fn into_fragment(self, ctx: &MathContext, styles: StyleChain) -> MathFragment {
+ if self.0.len() == 1 {
+ return self.0.into_iter().next().unwrap();
+ }
+
+ // Fragments without a math_size are ignored: the notion of size do not
+ // apply to them, so their text-likeness is meaningless.
+ let text_like = self
+ .iter()
+ .filter(|e| e.math_size().is_some())
+ .all(|e| e.is_text_like());
+
+ FrameFragment::new(ctx, styles, self.into_frame(ctx, styles))
+ .with_text_like(text_like)
+ .into()
+ }
+
+ /// Returns a builder that lays out the [`MathFragment`]s into a possibly
+ /// multi-row [`Frame`]. The rows are aligned using the same set of alignment
+ /// points computed from them as a whole.
+ pub fn multiline_frame_builder(
+ self,
+ ctx: &MathContext,
+ styles: StyleChain,
+ ) -> MathRunFrameBuilder {
+ let rows: Vec<_> = self.rows();
+ let row_count = rows.len();
+ let alignments = alignments(&rows);
+
+ let leading = if EquationElem::size_in(styles) >= MathSize::Text {
+ ParElem::leading_in(styles)
+ } else {
+ let font_size = scaled_font_size(ctx, styles);
+ TIGHT_LEADING.at(font_size)
+ };
+
+ let align = AlignElem::alignment_in(styles).resolve(styles).x;
+ let mut frames: Vec<(Frame, Point)> = vec![];
+ let mut size = Size::zero();
+ for (i, row) in rows.into_iter().enumerate() {
+ if i == row_count - 1 && row.0.is_empty() {
+ continue;
+ }
+
+ let sub = row.into_line_frame(&alignments.points, LeftRightAlternator::Right);
+ if i > 0 {
+ size.y += leading;
+ }
+
+ let mut pos = Point::with_y(size.y);
+ if alignments.points.is_empty() {
+ pos.x = align.position(alignments.width - sub.width());
+ }
+ size.x.set_max(sub.width());
+ size.y += sub.height();
+ frames.push((sub, pos));
+ }
+
+ MathRunFrameBuilder { size, frames }
+ }
+
+ /// Lay out [`MathFragment`]s into a one-row [`Frame`], using the
+ /// caller-provided alignment points.
+ pub fn into_line_frame(
+ self,
+ points: &[Abs],
+ mut alternator: LeftRightAlternator,
+ ) -> Frame {
+ let ascent = self.ascent();
+ let mut frame = Frame::soft(Size::new(Abs::zero(), ascent + self.descent()));
+ frame.set_baseline(ascent);
+
+ let mut next_x = {
+ let widths: Vec<Abs> = if points.is_empty() {
+ vec![]
+ } else {
+ self.iter()
+ .as_slice()
+ .split(|e| matches!(e, MathFragment::Align))
+ .map(|chunk| chunk.iter().map(|e| e.width()).sum())
+ .collect()
+ };
+
+ let mut prev_points = once(Abs::zero()).chain(points.iter().copied());
+ let mut point_widths = points.iter().copied().zip(widths);
+ move || {
+ point_widths
+ .next()
+ .zip(prev_points.next())
+ .zip(alternator.next())
+ .map(|(((point, width), prev_point), alternator)| match alternator {
+ LeftRightAlternator::Right => point - width,
+ _ => prev_point,
+ })
+ }
+ };
+ let mut x = next_x().unwrap_or_default();
+
+ for fragment in self.0.into_iter() {
+ if matches!(fragment, MathFragment::Align) {
+ x = next_x().unwrap_or(x);
+ continue;
+ }
+
+ let y = ascent - fragment.ascent();
+ let pos = Point::new(x, y);
+ x += fragment.width();
+ frame.push_frame(pos, fragment.into_frame());
+ }
+
+ frame.size_mut().x = x;
+ frame
+ }
+
+ pub fn into_par_items(self) -> Vec<InlineItem> {
+ let mut items = vec![];
+
+ let mut x = Abs::zero();
+ let mut ascent = Abs::zero();
+ let mut descent = Abs::zero();
+ let mut frame = Frame::soft(Size::zero());
+ let mut empty = true;
+
+ let finalize_frame = |frame: &mut Frame, x, ascent, descent| {
+ frame.set_size(Size::new(x, ascent + descent));
+ frame.set_baseline(Abs::zero());
+ frame.translate(Point::with_y(ascent));
+ };
+
+ let mut space_is_visible = false;
+
+ let is_relation = |f: &MathFragment| matches!(f.class(), MathClass::Relation);
+ let is_space = |f: &MathFragment| {
+ matches!(f, MathFragment::Space(_) | MathFragment::Spacing(_, _))
+ };
+
+ let mut iter = self.0.into_iter().peekable();
+ while let Some(fragment) = iter.next() {
+ if space_is_visible {
+ match fragment {
+ MathFragment::Space(width) | MathFragment::Spacing(width, _) => {
+ items.push(InlineItem::Space(width, true));
+ continue;
+ }
+ _ => {}
+ }
+ }
+
+ let class = fragment.class();
+ let y = fragment.ascent();
+
+ ascent.set_max(y);
+ descent.set_max(fragment.descent());
+
+ let pos = Point::new(x, -y);
+ x += fragment.width();
+ frame.push_frame(pos, fragment.into_frame());
+ empty = false;
+
+ if class == MathClass::Binary
+ || (class == MathClass::Relation
+ && !iter.peek().map(is_relation).unwrap_or_default())
+ {
+ let mut frame_prev =
+ std::mem::replace(&mut frame, Frame::soft(Size::zero()));
+
+ finalize_frame(&mut frame_prev, x, ascent, descent);
+ items.push(InlineItem::Frame(frame_prev));
+ empty = true;
+
+ x = Abs::zero();
+ ascent = Abs::zero();
+ descent = Abs::zero();
+
+ space_is_visible = true;
+ if let Some(f_next) = iter.peek() {
+ if !is_space(f_next) {
+ items.push(InlineItem::Space(Abs::zero(), true));
+ }
+ }
+ } else {
+ space_is_visible = false;
+ }
+ }
+
+ // Don't use `frame.is_empty()` because even an empty frame can
+ // contribute width (if it had hidden content).
+ if !empty {
+ finalize_frame(&mut frame, x, ascent, descent);
+ items.push(InlineItem::Frame(frame));
+ }
+
+ items
+ }
+
+ pub fn is_multiline(&self) -> bool {
+ self.iter().any(|frag| matches!(frag, MathFragment::Linebreak))
+ }
+}
+
+impl<T: Into<MathFragment>> From<T> for MathRun {
+ fn from(fragment: T) -> Self {
+ Self(vec![fragment.into()])
+ }
+}
+
+/// An iterator that alternates between the `Left` and `Right` values, if the
+/// initial value is not `None`.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum LeftRightAlternator {
+ None,
+ Left,
+ Right,
+}
+
+impl Iterator for LeftRightAlternator {
+ type Item = LeftRightAlternator;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let r = Some(*self);
+ match self {
+ Self::None => {}
+ Self::Left => *self = Self::Right,
+ Self::Right => *self = Self::Left,
+ }
+ r
+ }
+}
+
+/// How the rows from the [`MathRun`] should be aligned and merged into a [`Frame`].
+pub struct MathRunFrameBuilder {
+ /// The size of the resulting frame.
+ pub size: Size,
+ /// Each row's frame, and the position where the frame should
+ /// be pushed into the resulting frame.
+ pub frames: Vec<(Frame, Point)>,
+}
+
+impl MathRunFrameBuilder {
+ /// Consumes the builder and returns a [`Frame`].
+ pub fn build(self) -> Frame {
+ let mut frame = Frame::soft(self.size);
+ for (sub, pos) in self.frames.into_iter() {
+ frame.push_frame(pos, sub);
+ }
+ frame
+ }
+}
+
+fn affects_row_height(fragment: &MathFragment) -> bool {
+ !matches!(fragment, MathFragment::Align | MathFragment::Linebreak)
+}
+
+/// Create the spacing between two fragments in a given style.
+fn spacing(
+ l: &MathFragment,
+ space: Option<MathFragment>,
+ r: &MathFragment,
+) -> Option<MathFragment> {
+ use MathClass::*;
+
+ let resolve = |v: Em, size_ref: &MathFragment| -> Option<MathFragment> {
+ let width = size_ref.font_size().map_or(Abs::zero(), |size| v.at(size));
+ Some(MathFragment::Spacing(width, false))
+ };
+ let script = |f: &MathFragment| f.math_size().is_some_and(|s| s <= MathSize::Script);
+
+ match (l.class(), r.class()) {
+ // No spacing before punctuation; thin spacing after punctuation, unless
+ // in script size.
+ (_, Punctuation) => None,
+ (Punctuation, _) if !script(l) => resolve(THIN, l),
+
+ // No spacing after opening delimiters and before closing delimiters.
+ (Opening, _) | (_, Closing) => None,
+
+ // Thick spacing around relations, unless followed by a another relation
+ // or in script size.
+ (Relation, Relation) => None,
+ (Relation, _) if !script(l) => resolve(THICK, l),
+ (_, Relation) if !script(r) => resolve(THICK, r),
+
+ // Medium spacing around binary operators, unless in script size.
+ (Binary, _) if !script(l) => resolve(MEDIUM, l),
+ (_, Binary) if !script(r) => resolve(MEDIUM, r),
+
+ // Thin spacing around large operators, unless to the left of
+ // an opening delimiter. TeXBook, p170
+ (Large, Opening | Fence) => None,
+ (Large, _) => resolve(THIN, l),
+ (_, Large) => resolve(THIN, r),
+
+ // Spacing around spaced frames.
+ _ if (l.is_spaced() || r.is_spaced()) => space,
+
+ _ => None,
+ }
+}
diff --git a/crates/typst-layout/src/math/shared.rs b/crates/typst-layout/src/math/shared.rs
new file mode 100644
index 00000000..13477c10
--- /dev/null
+++ b/crates/typst-layout/src/math/shared.rs
@@ -0,0 +1,207 @@
+use ttf_parser::math::MathValue;
+use typst_library::foundations::{Style, StyleChain};
+use typst_library::layout::{Abs, Em, FixedAlignment, Frame, Point, Size, VAlignment};
+use typst_library::math::{EquationElem, MathSize};
+use typst_library::text::TextElem;
+use typst_utils::LazyHash;
+
+use super::{LeftRightAlternator, MathContext, MathFragment, MathRun};
+
+macro_rules! scaled {
+ ($ctx:expr, $styles:expr, text: $text:ident, display: $display:ident $(,)?) => {
+ match typst_library::math::EquationElem::size_in($styles) {
+ typst_library::math::MathSize::Display => scaled!($ctx, $styles, $display),
+ _ => scaled!($ctx, $styles, $text),
+ }
+ };
+ ($ctx:expr, $styles:expr, $name:ident) => {
+ $crate::math::Scaled::scaled(
+ $ctx.constants.$name(),
+ $ctx,
+ $crate::math::scaled_font_size($ctx, $styles),
+ )
+ };
+}
+
+macro_rules! percent {
+ ($ctx:expr, $name:ident) => {
+ $ctx.constants.$name() as f64 / 100.0
+ };
+}
+
+/// How much less high scaled delimiters can be than what they wrap.
+pub const DELIM_SHORT_FALL: Em = Em::new(0.1);
+
+/// Converts some unit to an absolute length with the current font & font size.
+pub trait Scaled {
+ fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs;
+}
+
+impl Scaled for i16 {
+ 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, font_size: Abs) -> Abs {
+ ctx.font.to_em(self).at(font_size)
+ }
+}
+
+impl Scaled for MathValue<'_> {
+ fn scaled(self, ctx: &MathContext, font_size: Abs) -> Abs {
+ self.value.scaled(ctx, font_size)
+ }
+}
+
+/// Get the font size scaled with the `MathSize`.
+pub fn scaled_font_size(ctx: &MathContext, styles: StyleChain) -> Abs {
+ let factor = match EquationElem::size_in(styles) {
+ MathSize::Display | MathSize::Text => 1.0,
+ MathSize::Script => percent!(ctx, script_percent_scale_down),
+ MathSize::ScriptScript => percent!(ctx, script_script_percent_scale_down),
+ };
+ factor * TextElem::size_in(styles)
+}
+
+/// Styles something as cramped.
+pub fn style_cramped() -> LazyHash<Style> {
+ EquationElem::set_cramped(true).wrap()
+}
+
+/// The style for subscripts in the current style.
+pub fn style_for_subscript(styles: StyleChain) -> [LazyHash<Style>; 2] {
+ [style_for_superscript(styles), EquationElem::set_cramped(true).wrap()]
+}
+
+/// The style for superscripts in the current style.
+pub fn style_for_superscript(styles: StyleChain) -> LazyHash<Style> {
+ EquationElem::set_size(match EquationElem::size_in(styles) {
+ MathSize::Display | MathSize::Text => MathSize::Script,
+ MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
+ })
+ .wrap()
+}
+
+/// The style for numerators in the current style.
+pub fn style_for_numerator(styles: StyleChain) -> LazyHash<Style> {
+ EquationElem::set_size(match EquationElem::size_in(styles) {
+ MathSize::Display => MathSize::Text,
+ MathSize::Text => MathSize::Script,
+ MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
+ })
+ .wrap()
+}
+
+/// The style for denominators in the current style.
+pub fn style_for_denominator(styles: StyleChain) -> [LazyHash<Style>; 2] {
+ [style_for_numerator(styles), EquationElem::set_cramped(true).wrap()]
+}
+
+/// How a delimieter should be aligned when scaling.
+pub fn delimiter_alignment(delimiter: char) -> VAlignment {
+ match delimiter {
+ '⌜' | '⌝' => VAlignment::Top,
+ '⌞' | '⌟' => VAlignment::Bottom,
+ _ => VAlignment::Horizon,
+ }
+}
+
+/// Stack rows on top of each other.
+///
+/// Add a `gap` between each row and uses the baseline of the `baseline`-th
+/// row for the whole frame. `alternator` controls the left/right alternating
+/// alignment behavior of `AlignPointElem` in the rows.
+pub fn stack(
+ rows: Vec<MathRun>,
+ align: FixedAlignment,
+ gap: Abs,
+ baseline: usize,
+ alternator: LeftRightAlternator,
+ minimum_ascent_descent: Option<(Abs, Abs)>,
+) -> Frame {
+ let rows: Vec<_> = rows.into_iter().flat_map(|r| r.rows()).collect();
+ let AlignmentResult { points, width } = alignments(&rows);
+ let rows: Vec<_> = rows
+ .into_iter()
+ .map(|row| row.into_line_frame(&points, alternator))
+ .collect();
+
+ let padded_height = |height: Abs| {
+ height.max(minimum_ascent_descent.map_or(Abs::zero(), |(a, d)| a + d))
+ };
+
+ let mut frame = Frame::soft(Size::new(
+ width,
+ rows.iter().map(|row| padded_height(row.height())).sum::<Abs>()
+ + rows.len().saturating_sub(1) as f64 * gap,
+ ));
+
+ let mut y = Abs::zero();
+ for (i, row) in rows.into_iter().enumerate() {
+ let x = if points.is_empty() {
+ align.position(width - row.width())
+ } else {
+ Abs::zero()
+ };
+ let ascent_padded_part = minimum_ascent_descent
+ .map_or(Abs::zero(), |(a, _)| (a - row.ascent()))
+ .max(Abs::zero());
+ let pos = Point::new(x, y + ascent_padded_part);
+ if i == baseline {
+ frame.set_baseline(y + row.baseline() + ascent_padded_part);
+ }
+ y += padded_height(row.height()) + gap;
+ frame.push_frame(pos, row);
+ }
+
+ frame
+}
+
+/// Determine the positions of the alignment points, according to the input rows combined.
+pub fn alignments(rows: &[MathRun]) -> AlignmentResult {
+ let mut widths = Vec::<Abs>::new();
+
+ let mut pending_width = Abs::zero();
+ for row in rows {
+ let mut width = Abs::zero();
+ let mut alignment_index = 0;
+
+ for fragment in row.iter() {
+ if matches!(fragment, MathFragment::Align) {
+ if alignment_index < widths.len() {
+ widths[alignment_index].set_max(width);
+ } else {
+ widths.push(width.max(pending_width));
+ }
+ width = Abs::zero();
+ alignment_index += 1;
+ } else {
+ width += fragment.width();
+ }
+ }
+ if widths.is_empty() {
+ pending_width.set_max(width);
+ } else if alignment_index < widths.len() {
+ widths[alignment_index].set_max(width);
+ } else {
+ widths.push(width.max(pending_width));
+ }
+ }
+
+ let mut points = widths;
+ for i in 1..points.len() {
+ let prev = points[i - 1];
+ points[i] += prev;
+ }
+ AlignmentResult {
+ width: points.last().copied().unwrap_or(pending_width),
+ points,
+ }
+}
+
+pub struct AlignmentResult {
+ pub points: Vec<Abs>,
+ pub width: Abs,
+}
diff --git a/crates/typst-layout/src/math/stretch.rs b/crates/typst-layout/src/math/stretch.rs
new file mode 100644
index 00000000..6dc82014
--- /dev/null
+++ b/crates/typst-layout/src/math/stretch.rs
@@ -0,0 +1,291 @@
+use ttf_parser::math::{GlyphAssembly, GlyphConstruction, GlyphPart};
+use ttf_parser::LazyArray16;
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Packed, Smart, StyleChain};
+use typst_library::layout::{Abs, Axis, Frame, Length, Point, Rel, Size};
+use typst_library::math::StretchElem;
+use typst_utils::Get;
+
+use super::{
+ delimiter_alignment, scaled_font_size, GlyphFragment, MathContext, MathFragment,
+ Scaled, VariantFragment,
+};
+
+/// Maximum number of times extenders can be repeated.
+const MAX_REPEATS: usize = 1024;
+
+/// Lays out a [`StretchElem`].
+#[typst_macros::time(name = "math.stretch", span = elem.span())]
+pub fn layout_stretch(
+ elem: &Packed<StretchElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let mut fragment = ctx.layout_into_fragment(elem.body(), styles)?;
+ stretch_fragment(
+ ctx,
+ styles,
+ &mut fragment,
+ None,
+ None,
+ elem.size(styles),
+ Abs::zero(),
+ );
+ ctx.push(fragment);
+ Ok(())
+}
+
+/// Attempts to stretch the given fragment by/to the amount given in stretch.
+pub fn stretch_fragment(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ fragment: &mut MathFragment,
+ axis: Option<Axis>,
+ relative_to: Option<Abs>,
+ stretch: Smart<Rel<Length>>,
+ short_fall: Abs,
+) {
+ let glyph = match fragment {
+ MathFragment::Glyph(glyph) => glyph.clone(),
+ MathFragment::Variant(variant) => {
+ GlyphFragment::new(ctx, styles, variant.c, variant.span)
+ }
+ _ => return,
+ };
+
+ // Return if we attempt to stretch along an axis which isn't stretchable,
+ // so that the original fragment isn't modified.
+ let Some(stretch_axis) = stretch_axis(ctx, &glyph) else { return };
+ let axis = axis.unwrap_or(stretch_axis);
+ if axis != stretch_axis {
+ return;
+ }
+
+ let relative_to_size = relative_to.unwrap_or_else(|| fragment.size().get(axis));
+
+ let mut variant = stretch_glyph(
+ ctx,
+ glyph,
+ stretch
+ .unwrap_or(Rel::one())
+ .at(scaled_font_size(ctx, styles))
+ .relative_to(relative_to_size),
+ short_fall,
+ axis,
+ );
+
+ if axis == Axis::Y {
+ variant.align_on_axis(ctx, delimiter_alignment(variant.c));
+ }
+
+ *fragment = MathFragment::Variant(variant);
+}
+
+/// Try to stretch a glyph to a desired width or height.
+///
+/// The resulting frame may not have the exact desired width.
+pub fn stretch_glyph(
+ ctx: &MathContext,
+ mut base: GlyphFragment,
+ target: Abs,
+ short_fall: Abs,
+ axis: Axis,
+) -> VariantFragment {
+ // If the base glyph is good enough, use it.
+ let advance = match axis {
+ Axis::X => base.width,
+ Axis::Y => base.height(),
+ };
+ let short_target = target - short_fall;
+ if short_target <= advance {
+ return base.into_variant();
+ }
+
+ let mut min_overlap = Abs::zero();
+ let construction = ctx
+ .table
+ .variants
+ .and_then(|variants| {
+ min_overlap = variants.min_connector_overlap.scaled(ctx, base.font_size);
+ match axis {
+ Axis::X => variants.horizontal_constructions,
+ Axis::Y => variants.vertical_constructions,
+ }
+ .get(base.id)
+ })
+ .unwrap_or(GlyphConstruction { assembly: None, variants: LazyArray16::new(&[]) });
+
+ // Search for a pre-made variant with a good advance.
+ let mut best_id = base.id;
+ let mut best_advance = base.width;
+ for variant in construction.variants {
+ best_id = variant.variant_glyph;
+ best_advance = base.font.to_em(variant.advance_measurement).at(base.font_size);
+ if short_target <= best_advance {
+ break;
+ }
+ }
+
+ // This is either good or the best we've got.
+ if short_target <= best_advance || construction.assembly.is_none() {
+ base.set_id(ctx, best_id);
+ return base.into_variant();
+ }
+
+ // Assemble from parts.
+ let assembly = construction.assembly.unwrap();
+ assemble(ctx, base, assembly, min_overlap, target, axis)
+}
+
+/// Return whether the glyph is stretchable and if it is, along which axis it
+/// can be stretched.
+fn stretch_axis(ctx: &MathContext, base: &GlyphFragment) -> Option<Axis> {
+ let base_id = base.id;
+ let vertical = ctx
+ .table
+ .variants
+ .and_then(|variants| variants.vertical_constructions.get(base_id))
+ .map(|_| Axis::Y);
+ let horizontal = ctx
+ .table
+ .variants
+ .and_then(|variants| variants.horizontal_constructions.get(base_id))
+ .map(|_| Axis::X);
+
+ match (vertical, horizontal) {
+ (vertical, None) => vertical,
+ (None, horizontal) => horizontal,
+ _ => {
+ // As far as we know, there aren't any glyphs that have both
+ // vertical and horizontal constructions. So for the time being, we
+ // will assume that a glyph cannot have both.
+ panic!("glyph {:?} has both vertical and horizontal constructions", base.c);
+ }
+ }
+}
+
+/// Assemble a glyph from parts.
+fn assemble(
+ ctx: &MathContext,
+ base: GlyphFragment,
+ assembly: GlyphAssembly,
+ min_overlap: Abs,
+ target: Abs,
+ axis: Axis,
+) -> VariantFragment {
+ // Determine the number of times the extenders need to be repeated as well
+ // as a ratio specifying how much to spread the parts apart
+ // (0 = maximal overlap, 1 = minimal overlap).
+ let mut full;
+ let mut ratio;
+ let mut repeat = 0;
+ loop {
+ full = Abs::zero();
+ ratio = 0.0;
+
+ let mut parts = parts(assembly, repeat).peekable();
+ let mut growable = Abs::zero();
+
+ while let Some(part) = parts.next() {
+ 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, base.font_size);
+
+ advance -= max_overlap;
+ growable += max_overlap - min_overlap;
+ }
+
+ full += advance;
+ }
+
+ if full < target {
+ let delta = target - full;
+ ratio = (delta / growable).min(1.0);
+ full += ratio * growable;
+ }
+
+ if target <= full || repeat >= MAX_REPEATS {
+ break;
+ }
+
+ repeat += 1;
+ }
+
+ 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, base.font_size);
+ if let Some(next) = parts.peek() {
+ 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);
+ }
+
+ let mut fragment = base.clone();
+ fragment.set_id(ctx, part.glyph_id);
+ selected.push((fragment, advance));
+ }
+
+ let size;
+ let baseline;
+ match axis {
+ Axis::X => {
+ let height = base.ascent + base.descent;
+ size = Size::new(full, height);
+ baseline = base.ascent;
+ }
+ Axis::Y => {
+ 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;
+ }
+ }
+
+ let mut frame = Frame::soft(size);
+ let mut offset = Abs::zero();
+ frame.set_baseline(baseline);
+ frame.post_process_raw(base.dests, base.hidden);
+
+ for (fragment, advance) in selected {
+ let pos = match axis {
+ Axis::X => Point::new(offset, frame.baseline() - fragment.ascent),
+ Axis::Y => Point::with_y(full - offset - fragment.height()),
+ };
+ frame.push_frame(pos, fragment.into_frame());
+ offset += advance;
+ }
+
+ let accent_attach = match axis {
+ Axis::X => frame.width() / 2.0,
+ Axis::Y => base.accent_attach,
+ };
+
+ VariantFragment {
+ c: base.c,
+ frame,
+ 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,
+ }
+}
+
+/// Return an iterator over the assembly's parts with extenders repeated the
+/// specified number of times.
+fn parts(assembly: GlyphAssembly, repeat: usize) -> impl Iterator<Item = GlyphPart> + '_ {
+ assembly.parts.into_iter().flat_map(move |part| {
+ let count = if part.part_flags.extender() { repeat } else { 1 };
+ std::iter::repeat(part).take(count)
+ })
+}
diff --git a/crates/typst-layout/src/math/text.rs b/crates/typst-layout/src/math/text.rs
new file mode 100644
index 00000000..df80b45a
--- /dev/null
+++ b/crates/typst-layout/src/math/text.rs
@@ -0,0 +1,344 @@
+use std::f64::consts::SQRT_2;
+
+use ecow::{eco_vec, EcoString};
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Packed, StyleChain, StyleVec};
+use typst_library::layout::{Abs, Size};
+use typst_library::math::{EquationElem, MathSize, MathVariant};
+use typst_library::text::{
+ BottomEdge, BottomEdgeMetric, TextElem, TextSize, TopEdge, TopEdgeMetric,
+};
+use typst_syntax::{is_newline, Span};
+use unicode_math_class::MathClass;
+use unicode_segmentation::UnicodeSegmentation;
+
+use super::{
+ scaled_font_size, FrameFragment, GlyphFragment, MathContext, MathFragment, MathRun,
+};
+
+/// Lays out a [`TextElem`].
+pub fn layout_text(
+ elem: &Packed<TextElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ let text = elem.text();
+ let span = elem.span();
+ let mut chars = text.chars();
+ let math_size = EquationElem::size_in(styles);
+
+ let fragment: MathFragment = if let Some(mut glyph) = chars
+ .next()
+ .filter(|_| chars.next().is_none())
+ .map(|c| styled_char(styles, c, true))
+ .and_then(|c| GlyphFragment::try_new(ctx, styles, c, span))
+ {
+ // A single letter that is available in the math font.
+ match math_size {
+ MathSize::Script => {
+ glyph.make_scriptsize(ctx);
+ }
+ MathSize::ScriptScript => {
+ glyph.make_scriptscriptsize(ctx);
+ }
+ _ => (),
+ }
+
+ if glyph.class == MathClass::Large {
+ let mut variant = if math_size == MathSize::Display {
+ let height = scaled!(ctx, styles, display_operator_min_height)
+ .max(SQRT_2 * glyph.height());
+ glyph.stretch_vertical(ctx, height, Abs::zero())
+ } else {
+ glyph.into_variant()
+ };
+ // TeXbook p 155. Large operators are always vertically centered on the axis.
+ variant.center_on_axis(ctx);
+ variant.into()
+ } else {
+ glyph.into()
+ }
+ } else if text.chars().all(|c| c.is_ascii_digit() || c == '.') {
+ // Numbers aren't that difficult.
+ let mut fragments = vec![];
+ for c in text.chars() {
+ let c = styled_char(styles, c, false);
+ fragments.push(GlyphFragment::new(ctx, styles, c, span).into());
+ }
+ let frame = MathRun::new(fragments).into_frame(ctx, styles);
+ FrameFragment::new(ctx, 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(ctx, styles).into())),
+ ]
+ .map(|p| p.wrap());
+
+ // Anything else is handled by Typst's standard text layout.
+ let styles = styles.chain(&local);
+ let text: EcoString =
+ text.chars().map(|c| styled_char(styles, c, false)).collect();
+ if text.contains(is_newline) {
+ let mut fragments = vec![];
+ for (i, piece) in text.split(is_newline).enumerate() {
+ if i != 0 {
+ fragments.push(MathFragment::Linebreak);
+ }
+ if !piece.is_empty() {
+ fragments.push(layout_complex_text(piece, ctx, span, styles)?.into());
+ }
+ }
+ let mut frame = MathRun::new(fragments).into_frame(ctx, styles);
+ let axis = scaled!(ctx, styles, axis_height);
+ frame.set_baseline(frame.height() / 2.0 + axis);
+ FrameFragment::new(ctx, styles, frame).into()
+ } else {
+ layout_complex_text(&text, ctx, span, styles)?.into()
+ }
+ };
+
+ ctx.push(fragment);
+ Ok(())
+}
+
+/// Layout the given text string into a [`FrameFragment`].
+fn layout_complex_text(
+ text: &str,
+ ctx: &mut MathContext,
+ span: Span,
+ styles: StyleChain,
+) -> SourceResult<FrameFragment> {
+ // 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
+ // to extend as far as needed.
+ let spaced = text.graphemes(true).nth(1).is_some();
+ let elem = TextElem::packed(text).spanned(span);
+ let frame = (ctx.engine.routines.layout_inline)(
+ ctx.engine,
+ &StyleVec::wrap(eco_vec![elem]),
+ ctx.locator.next(&span),
+ styles,
+ false,
+ Size::splat(Abs::inf()),
+ false,
+ )?
+ .into_frame();
+
+ Ok(FrameFragment::new(ctx, styles, frame)
+ .with_class(MathClass::Alphabetic)
+ .with_text_like(true)
+ .with_spaced(spaced))
+}
+
+/// 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>
+fn styled_char(styles: StyleChain, c: char, auto_italic: bool) -> char {
+ use MathVariant::*;
+
+ let variant = EquationElem::variant_in(styles);
+ let bold = EquationElem::bold_in(styles);
+ let italic = EquationElem::italic_in(styles).unwrap_or(
+ auto_italic
+ && matches!(
+ c,
+ 'a'..='z' | 'ı' | 'ȷ' | 'A'..='Z' | 'α'..='ω' |
+ '∂' | 'ϵ' | 'ϑ' | 'ϰ' | 'ϕ' | 'ϱ' | 'ϖ'
+ )
+ && matches!(variant, Sans | Serif),
+ );
+
+ if let Some(c) = basic_exception(c) {
+ return c;
+ }
+
+ if let Some(c) = latin_exception(c, variant, bold, italic) {
+ return c;
+ }
+
+ if let Some(c) = greek_exception(c, variant, bold, italic) {
+ return c;
+ }
+
+ let base = match c {
+ 'A'..='Z' => 'A',
+ 'a'..='z' => 'a',
+ 'Α'..='Ω' => 'Α',
+ 'α'..='ω' => 'α',
+ '0'..='9' => '0',
+ // Hebrew Alef -> Dalet.
+ '\u{05D0}'..='\u{05D3}' => '\u{05D0}',
+ _ => return c,
+ };
+
+ let tuple = (variant, bold, italic);
+ let start = match c {
+ // Latin upper.
+ 'A'..='Z' => match tuple {
+ (Serif, false, false) => 0x0041,
+ (Serif, true, false) => 0x1D400,
+ (Serif, false, true) => 0x1D434,
+ (Serif, true, true) => 0x1D468,
+ (Sans, false, false) => 0x1D5A0,
+ (Sans, true, false) => 0x1D5D4,
+ (Sans, false, true) => 0x1D608,
+ (Sans, true, true) => 0x1D63C,
+ (Cal, false, _) => 0x1D49C,
+ (Cal, true, _) => 0x1D4D0,
+ (Frak, false, _) => 0x1D504,
+ (Frak, true, _) => 0x1D56C,
+ (Mono, _, _) => 0x1D670,
+ (Bb, _, _) => 0x1D538,
+ },
+
+ // Latin lower.
+ 'a'..='z' => match tuple {
+ (Serif, false, false) => 0x0061,
+ (Serif, true, false) => 0x1D41A,
+ (Serif, false, true) => 0x1D44E,
+ (Serif, true, true) => 0x1D482,
+ (Sans, false, false) => 0x1D5BA,
+ (Sans, true, false) => 0x1D5EE,
+ (Sans, false, true) => 0x1D622,
+ (Sans, true, true) => 0x1D656,
+ (Cal, false, _) => 0x1D4B6,
+ (Cal, true, _) => 0x1D4EA,
+ (Frak, false, _) => 0x1D51E,
+ (Frak, true, _) => 0x1D586,
+ (Mono, _, _) => 0x1D68A,
+ (Bb, _, _) => 0x1D552,
+ },
+
+ // Greek upper.
+ 'Α'..='Ω' => match tuple {
+ (Serif, false, false) => 0x0391,
+ (Serif, true, false) => 0x1D6A8,
+ (Serif, false, true) => 0x1D6E2,
+ (Serif, true, true) => 0x1D71C,
+ (Sans, _, false) => 0x1D756,
+ (Sans, _, true) => 0x1D790,
+ (Cal | Frak | Mono | Bb, _, _) => return c,
+ },
+
+ // Greek lower.
+ 'α'..='ω' => match tuple {
+ (Serif, false, false) => 0x03B1,
+ (Serif, true, false) => 0x1D6C2,
+ (Serif, false, true) => 0x1D6FC,
+ (Serif, true, true) => 0x1D736,
+ (Sans, _, false) => 0x1D770,
+ (Sans, _, true) => 0x1D7AA,
+ (Cal | Frak | Mono | Bb, _, _) => return c,
+ },
+
+ // Hebrew Alef -> Dalet.
+ '\u{05D0}'..='\u{05D3}' => 0x2135,
+
+ // Numbers.
+ '0'..='9' => match tuple {
+ (Serif, false, _) => 0x0030,
+ (Serif, true, _) => 0x1D7CE,
+ (Bb, _, _) => 0x1D7D8,
+ (Sans, false, _) => 0x1D7E2,
+ (Sans, true, _) => 0x1D7EC,
+ (Mono, _, _) => 0x1D7F6,
+ (Cal | Frak, _, _) => return c,
+ },
+
+ _ => unreachable!(),
+ };
+
+ std::char::from_u32(start + (c as u32 - base as u32)).unwrap()
+}
+
+fn basic_exception(c: char) -> Option<char> {
+ Some(match c {
+ '〈' => '⟨',
+ '〉' => '⟩',
+ '《' => '⟪',
+ '》' => '⟫',
+ _ => return None,
+ })
+}
+
+fn latin_exception(
+ c: char,
+ variant: MathVariant,
+ bold: bool,
+ italic: bool,
+) -> Option<char> {
+ use MathVariant::*;
+ Some(match (c, variant, bold, italic) {
+ ('B', Cal, false, _) => 'ℬ',
+ ('E', Cal, false, _) => 'ℰ',
+ ('F', Cal, false, _) => 'ℱ',
+ ('H', Cal, false, _) => 'ℋ',
+ ('I', Cal, false, _) => 'ℐ',
+ ('L', Cal, false, _) => 'ℒ',
+ ('M', Cal, false, _) => 'ℳ',
+ ('R', Cal, false, _) => 'ℛ',
+ ('C', Frak, false, _) => 'ℭ',
+ ('H', Frak, false, _) => 'ℌ',
+ ('I', Frak, false, _) => 'ℑ',
+ ('R', Frak, false, _) => 'ℜ',
+ ('Z', Frak, false, _) => 'ℨ',
+ ('C', Bb, ..) => 'ℂ',
+ ('H', Bb, ..) => 'ℍ',
+ ('N', Bb, ..) => 'ℕ',
+ ('P', Bb, ..) => 'ℙ',
+ ('Q', Bb, ..) => 'ℚ',
+ ('R', Bb, ..) => 'ℝ',
+ ('Z', Bb, ..) => 'ℤ',
+ ('D', Bb, _, true) => 'ⅅ',
+ ('d', Bb, _, true) => 'ⅆ',
+ ('e', Bb, _, true) => 'ⅇ',
+ ('i', Bb, _, true) => 'ⅈ',
+ ('j', Bb, _, true) => 'ⅉ',
+ ('h', Serif, false, true) => 'ℎ',
+ ('e', Cal, false, _) => 'ℯ',
+ ('g', Cal, false, _) => 'ℊ',
+ ('o', Cal, false, _) => 'ℴ',
+ ('ı', Serif, .., true) => '𝚤',
+ ('ȷ', Serif, .., true) => '𝚥',
+ _ => return None,
+ })
+}
+
+fn greek_exception(
+ c: char,
+ variant: MathVariant,
+ bold: bool,
+ italic: bool,
+) -> Option<char> {
+ use MathVariant::*;
+ let list = match c {
+ 'ϴ' => ['𝚹', '𝛳', '𝜭', '𝝧', '𝞡', 'ϴ'],
+ '∇' => ['𝛁', '𝛻', '𝜵', '𝝯', '𝞩', '∇'],
+ '∂' => ['𝛛', '𝜕', '𝝏', '𝞉', '𝟃', '∂'],
+ 'ϵ' => ['𝛜', '𝜖', '𝝐', '𝞊', '𝟄', 'ϵ'],
+ 'ϑ' => ['𝛝', '𝜗', '𝝑', '𝞋', '𝟅', 'ϑ'],
+ 'ϰ' => ['𝛞', '𝜘', '𝝒', '𝞌', '𝟆', 'ϰ'],
+ 'ϕ' => ['𝛟', '𝜙', '𝝓', '𝞍', '𝟇', 'ϕ'],
+ 'ϱ' => ['𝛠', '𝜚', '𝝔', '𝞎', '𝟈', 'ϱ'],
+ 'ϖ' => ['𝛡', '𝜛', '𝝕', '𝞏', '𝟉', 'ϖ'],
+ 'Γ' => ['𝚪', '𝛤', '𝜞', '𝝘', '𝞒', 'ℾ'],
+ 'γ' => ['𝛄', '𝛾', '𝜸', '𝝲', '𝞬', 'ℽ'],
+ 'Π' => ['𝚷', '𝛱', '𝜫', '𝝥', '𝞟', 'ℿ'],
+ 'π' => ['𝛑', '𝜋', '𝝅', '𝝿', '𝞹', 'ℼ'],
+ '∑' => ['∑', '∑', '∑', '∑', '∑', '⅀'],
+ _ => return None,
+ };
+
+ Some(match (variant, bold, italic) {
+ (Serif, true, false) => list[0],
+ (Serif, false, true) => list[1],
+ (Serif, true, true) => list[2],
+ (Sans, _, false) => list[3],
+ (Sans, _, true) => list[4],
+ (Bb, ..) => list[5],
+ _ => return None,
+ })
+}
diff --git a/crates/typst-layout/src/math/underover.rs b/crates/typst-layout/src/math/underover.rs
new file mode 100644
index 00000000..b1d4825b
--- /dev/null
+++ b/crates/typst-layout/src/math/underover.rs
@@ -0,0 +1,327 @@
+use typst_library::diag::SourceResult;
+use typst_library::foundations::{Content, Packed, StyleChain};
+use typst_library::layout::{Abs, Em, FixedAlignment, Frame, FrameItem, Point, Size};
+use typst_library::math::{
+ OverbraceElem, OverbracketElem, OverlineElem, OverparenElem, OvershellElem,
+ UnderbraceElem, UnderbracketElem, UnderlineElem, UnderparenElem, UndershellElem,
+};
+use typst_library::text::TextElem;
+use typst_library::visualize::{FixedStroke, Geometry};
+use typst_syntax::Span;
+
+use super::{
+ scaled_font_size, stack, style_cramped, style_for_subscript, style_for_superscript,
+ FrameFragment, GlyphFragment, LeftRightAlternator, MathContext, MathRun,
+};
+
+const BRACE_GAP: Em = Em::new(0.25);
+const BRACKET_GAP: Em = Em::new(0.25);
+const PAREN_GAP: Em = Em::new(0.25);
+const SHELL_GAP: Em = Em::new(0.25);
+
+/// A marker to distinguish under- and overlines.
+enum Position {
+ Under,
+ Over,
+}
+
+/// Lays out an [`UnderlineElem`].
+#[typst_macros::time(name = "math.underline", span = elem.span())]
+pub fn layout_underline(
+ elem: &Packed<UnderlineElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverline(ctx, styles, elem.body(), elem.span(), Position::Under)
+}
+
+/// Lays out an [`OverlineElem`].
+#[typst_macros::time(name = "math.overline", span = elem.span())]
+pub fn layout_overline(
+ elem: &Packed<OverlineElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverline(ctx, styles, elem.body(), elem.span(), Position::Over)
+}
+
+/// Lays out an [`UnderbraceElem`].
+#[typst_macros::time(name = "math.underbrace", span = elem.span())]
+pub fn layout_underbrace(
+ elem: &Packed<UnderbraceElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⏟',
+ BRACE_GAP,
+ Position::Under,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`OverbraceElem`].
+#[typst_macros::time(name = "math.overbrace", span = elem.span())]
+pub fn layout_overbrace(
+ elem: &Packed<OverbraceElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⏞',
+ BRACE_GAP,
+ Position::Over,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`UnderbracketElem`].
+#[typst_macros::time(name = "math.underbracket", span = elem.span())]
+pub fn layout_underbracket(
+ elem: &Packed<UnderbracketElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⎵',
+ BRACKET_GAP,
+ Position::Under,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`OverbracketElem`].
+#[typst_macros::time(name = "math.overbracket", span = elem.span())]
+pub fn layout_overbracket(
+ elem: &Packed<OverbracketElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⎴',
+ BRACKET_GAP,
+ Position::Over,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`UnderparenElem`].
+#[typst_macros::time(name = "math.underparen", span = elem.span())]
+pub fn layout_underparen(
+ elem: &Packed<UnderparenElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⏝',
+ PAREN_GAP,
+ Position::Under,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`OverparenElem`].
+#[typst_macros::time(name = "math.overparen", span = elem.span())]
+pub fn layout_overparen(
+ elem: &Packed<OverparenElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⏜',
+ PAREN_GAP,
+ Position::Over,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`UndershellElem`].
+#[typst_macros::time(name = "math.undershell", span = elem.span())]
+pub fn layout_undershell(
+ elem: &Packed<UndershellElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⏡',
+ SHELL_GAP,
+ Position::Under,
+ elem.span(),
+ )
+}
+
+/// Lays out an [`OvershellElem`].
+#[typst_macros::time(name = "math.overshell", span = elem.span())]
+pub fn layout_overshell(
+ elem: &Packed<OvershellElem>,
+ ctx: &mut MathContext,
+ styles: StyleChain,
+) -> SourceResult<()> {
+ layout_underoverspreader(
+ ctx,
+ styles,
+ elem.body(),
+ &elem.annotation(styles),
+ '⏠',
+ SHELL_GAP,
+ Position::Over,
+ elem.span(),
+ )
+}
+
+/// layout under- or overlined content.
+fn layout_underoverline(
+ ctx: &mut MathContext,
+ styles: StyleChain,
+ body: &Content,
+ span: Span,
+ position: Position,
+) -> SourceResult<()> {
+ let (extra_height, content, line_pos, content_pos, baseline, bar_height, line_adjust);
+ match position {
+ Position::Under => {
+ 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_into_fragment(body, styles)?;
+
+ line_pos = Point::with_y(content.height() + gap + bar_height / 2.0);
+ content_pos = Point::zero();
+ baseline = content.ascent();
+ line_adjust = -content.italics_correction();
+ }
+ Position::Over => {
+ 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;
+
+ let cramped = style_cramped();
+ content = ctx.layout_into_fragment(body, styles.chain(&cramped))?;
+
+ line_pos = Point::with_y(sep + bar_height / 2.0);
+ content_pos = Point::with_y(extra_height);
+ baseline = content.ascent() + extra_height;
+ line_adjust = Abs::zero();
+ }
+ }
+
+ let width = content.width();
+ let height = content.height() + extra_height;
+ let size = Size::new(width, height);
+ let line_width = width + line_adjust;
+
+ let content_class = content.class();
+ let content_is_text_like = content.is_text_like();
+ let content_italics_correction = content.italics_correction();
+ let mut frame = Frame::soft(size);
+ frame.set_baseline(baseline);
+ frame.push_frame(content_pos, content.into_frame());
+ frame.push(
+ line_pos,
+ FrameItem::Shape(
+ Geometry::Line(Point::with_x(line_width)).stroked(FixedStroke {
+ paint: TextElem::fill_in(styles).as_decoration(),
+ thickness: bar_height,
+ ..FixedStroke::default()
+ }),
+ span,
+ ),
+ );
+
+ ctx.push(
+ FrameFragment::new(ctx, styles, frame)
+ .with_class(content_class)
+ .with_text_like(content_is_text_like)
+ .with_italics_correction(content_italics_correction),
+ );
+
+ Ok(())
+}
+
+/// 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,
+ gap: Em,
+ position: Position,
+ span: Span,
+) -> SourceResult<()> {
+ let font_size = scaled_font_size(ctx, styles);
+ let gap = gap.at(font_size);
+ let body = ctx.layout_into_run(body, styles)?;
+ let body_class = body.class();
+ 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![];
+ let baseline = match position {
+ Position::Under => {
+ rows.push(MathRun::new(vec![body]));
+ rows.push(stretched.into());
+ if let Some(annotation) = annotation {
+ let under_style = style_for_subscript(styles);
+ let annotation_styles = styles.chain(&under_style);
+ rows.push(ctx.layout_into_run(annotation, annotation_styles)?);
+ }
+ 0
+ }
+ Position::Over => {
+ if let Some(annotation) = annotation {
+ let over_style = style_for_superscript(styles);
+ let annotation_styles = styles.chain(&over_style);
+ rows.push(ctx.layout_into_run(annotation, annotation_styles)?);
+ }
+ rows.push(stretched.into());
+ rows.push(MathRun::new(vec![body]));
+ rows.len() - 1
+ }
+ };
+
+ let frame = stack(
+ rows,
+ FixedAlignment::Center,
+ gap,
+ baseline,
+ LeftRightAlternator::Right,
+ None,
+ );
+ ctx.push(FrameFragment::new(ctx, styles, frame).with_class(body_class));
+
+ Ok(())
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-16 00:45:46 +0000