Add delim-size parameter to mat, vec, and cases

Takes either a function or a relative length, just like with `lr`,
`stretch`, and `accent` which was changed in the previous two commits.
The default is now much clearer to the user: `x => x * 1.1 - 0.1em`.

crates/typst-cli/src/args.rs

@@ -491,7 +491,7 @@ pub enum PdfStandard {
     /// PDF/A-2u.
     #[value(name = "a-2u")]
     A_2u,
-    /// PDF/A-3b.
+    /// PDF/A-3u.
     #[value(name = "a-3b")]
     A_3b,
     /// PDF/A-3u.

crates/typst-kit/src/package.rs

@@ -199,7 +199,7 @@ impl PackageStorage {
         // The place at which the specific package version will live in the end.
         let package_dir = base_dir.join(format!("{}", spec.version));
 
-        // To prevent multiple Typst instances from interfering, we download
+        // To prevent multiple Typst instances from interferring, we download
         // into a temporary directory first and then move this directory to
         // its final destination.
         //

crates/typst-layout/src/inline/collect.rs

@@ -206,7 +206,7 @@ pub fn collect<'a>(
                     }
                     InlineItem::Frame(mut frame) => {
                         frame.modify(&FrameModifiers::get_in(styles));
-                        apply_shift(&engine.world, &mut frame, styles);
+                        apply_baseline_shift(&mut frame, styles);
                         collector.push_item(Item::Frame(frame));
                     }
                 }
@@ -221,7 +221,7 @@ pub fn collect<'a>(
                 let mut frame = layout_and_modify(styles, |styles| {
                     layout_box(elem, engine, loc, styles, region)
                 })?;
-                apply_shift(&engine.world, &mut frame, styles);
+                apply_baseline_shift(&mut frame, styles);
                 collector.push_item(Item::Frame(frame));
             }
         } else if let Some(elem) = child.to_packed::<TagElem>() {

crates/typst-layout/src/inline/line.rs

@@ -5,7 +5,7 @@ use typst_library::engine::Engine;
 use typst_library::introspection::{SplitLocator, Tag};
 use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point};
 use typst_library::model::ParLineMarker;
-use typst_library::text::{variant, Lang, TextElem};
+use typst_library::text::{Lang, TextElem};
 use typst_utils::Numeric;
 
 use super::*;
@@ -330,7 +330,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
         let glyph = shaped.glyphs.to_mut().first_mut().unwrap();
         let shrink = glyph.shrinkability().0;
         glyph.shrink_left(shrink);
-        shaped.width -= shrink.at(glyph.size);
+        shaped.width -= shrink.at(shaped.size);
     } else if p.config.cjk_latin_spacing
         && glyph.is_cj_script()
         && glyph.x_offset > Em::zero()
@@ -342,7 +342,7 @@ fn adjust_cj_at_line_start(p: &Preparation, items: &mut Items) {
         glyph.x_advance -= shrink;
         glyph.x_offset = Em::zero();
         glyph.adjustability.shrinkability.0 = Em::zero();
-        shaped.width -= shrink.at(glyph.size);
+        shaped.width -= shrink.at(shaped.size);
     }
 }
 
@@ -360,7 +360,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
         let shrink = glyph.shrinkability().1;
         let punct = shaped.glyphs.to_mut().last_mut().unwrap();
         punct.shrink_right(shrink);
-        shaped.width -= shrink.at(punct.size);
+        shaped.width -= shrink.at(shaped.size);
     } else if p.config.cjk_latin_spacing
         && glyph.is_cj_script()
         && (glyph.x_advance - glyph.x_offset) > Em::one()
@@ -371,7 +371,7 @@ fn adjust_cj_at_line_end(p: &Preparation, items: &mut Items) {
         let glyph = shaped.glyphs.to_mut().last_mut().unwrap();
         glyph.x_advance -= shrink;
         glyph.adjustability.shrinkability.1 = Em::zero();
-        shaped.width -= shrink.at(glyph.size);
+        shaped.width -= shrink.at(shaped.size);
     }
 }
 
@@ -412,30 +412,9 @@ fn should_repeat_hyphen(pred_line: &Line, text: &str) -> bool {
     }
 }
 
-/// Apply the current baseline shift and italic compensation to a frame.
+/// Apply the current baseline shift to a frame.
-pub fn apply_shift<'a>(
+pub fn apply_baseline_shift(frame: &mut Frame, styles: StyleChain) {
-    world: &Tracked<'a, dyn World + 'a>,
+    frame.translate(Point::with_y(TextElem::baseline_in(styles)));
-    frame: &mut Frame,
-    styles: StyleChain,
-) {
-    let mut baseline = TextElem::baseline_in(styles);
-    let mut compensation = Abs::zero();
-    if let Some(scripts) = TextElem::shift_settings_in(styles) {
-        let font_metrics = TextElem::font_in(styles)
-            .into_iter()
-            .find_map(|family| {
-                world
-                    .book()
-                    .select(family.as_str(), variant(styles))
-                    .and_then(|id| world.font(id))
-            })
-            .map_or(*scripts.kind.default_metrics(), |f| {
-                *scripts.kind.read_metrics(f.metrics())
-            });
-        baseline -= scripts.shift.unwrap_or(font_metrics.vertical_offset).resolve(styles);
-        compensation += font_metrics.horizontal_offset.resolve(styles);
-    }
-    frame.translate(Point::new(compensation, baseline));
 }
 
 /// Commit to a line and build its frame.
@@ -465,7 +444,7 @@ pub fn commit(
                 && TextElem::overhang_in(text.styles)
                 && (line.items.len() > 1 || text.glyphs.len() > 1)
             {
-                let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
+                let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
                 offset -= amount;
                 remaining += amount;
             }
@@ -479,7 +458,7 @@ pub fn commit(
                 && TextElem::overhang_in(text.styles)
                 && (line.items.len() > 1 || text.glyphs.len() > 1)
             {
-                let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
+                let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
                 remaining += amount;
             }
         }
@@ -540,7 +519,7 @@ pub fn commit(
                     let mut frame = layout_and_modify(*styles, |styles| {
                         layout_box(elem, engine, loc.relayout(), styles, region)
                     })?;
-                    apply_shift(&engine.world, &mut frame, *styles);
+                    apply_baseline_shift(&mut frame, *styles);
                     push(&mut offset, frame, idx);
                 } else {
                     offset += amount;

crates/typst-layout/src/inline/linebreak.rs

@@ -927,9 +927,9 @@ impl Estimates {
                     let byte_len = g.range.len();
                     let stretch = g.stretchability().0 + g.stretchability().1;
                     let shrink = g.shrinkability().0 + g.shrinkability().1;
-                    widths.push(byte_len, g.x_advance.at(g.size));
+                    widths.push(byte_len, g.x_advance.at(shaped.size));
-                    stretchability.push(byte_len, stretch.at(g.size));
+                    stretchability.push(byte_len, stretch.at(shaped.size));
-                    shrinkability.push(byte_len, shrink.at(g.size));
+                    shrinkability.push(byte_len, shrink.at(shaped.size));
                     justifiables.push(byte_len, g.is_justifiable() as usize);
                 }
             } else {

crates/typst-layout/src/inline/mod.rs

@@ -29,7 +29,7 @@ use typst_utils::{Numeric, SliceExt};
 use self::collect::{collect, Item, Segment, SpanMapper};
 use self::deco::decorate;
 use self::finalize::finalize;
-use self::line::{apply_shift, commit, line, Line};
+use self::line::{apply_baseline_shift, commit, line, Line};
 use self::linebreak::{linebreak, Breakpoint};
 use self::prepare::{prepare, Preparation};
 use self::shaping::{

crates/typst-layout/src/inline/prepare.rs

@@ -144,7 +144,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
                 // The spacing is default to 1/4 em, and can be shrunk to 1/8 em.
                 glyph.x_advance += Em::new(0.25);
                 glyph.adjustability.shrinkability.1 += Em::new(0.125);
-                text.width += Em::new(0.25).at(glyph.size);
+                text.width += Em::new(0.25).at(text.size);
             }
 
             // Case 2: Latin followed by a CJ character
@@ -152,7 +152,7 @@ fn add_cjk_latin_spacing(items: &mut [(Range, Item)]) {
                 glyph.x_advance += Em::new(0.25);
                 glyph.x_offset += Em::new(0.25);
                 glyph.adjustability.shrinkability.0 += Em::new(0.125);
-                text.width += Em::new(0.25).at(glyph.size);
+                text.width += Em::new(0.25).at(text.size);
             }
 
             prev = Some(glyph);

crates/typst-layout/src/inline/shaping.rs

@@ -3,15 +3,14 @@ use std::fmt::{self, Debug, Formatter};
 use std::sync::Arc;
 
 use az::SaturatingAs;
-use rustybuzz::{BufferFlags, Feature, ShapePlan, UnicodeBuffer};
+use rustybuzz::{BufferFlags, ShapePlan, UnicodeBuffer};
-use ttf_parser::gsub::SubstitutionSubtable;
 use ttf_parser::Tag;
 use typst_library::engine::Engine;
 use typst_library::foundations::{Smart, StyleChain};
 use typst_library::layout::{Abs, Dir, Em, Frame, FrameItem, Point, Size};
 use typst_library::text::{
     families, features, is_default_ignorable, language, variant, Font, FontFamily,
-    FontVariant, Glyph, Lang, Region, ShiftSettings, TextEdgeBounds, TextElem, TextItem,
+    FontVariant, Glyph, Lang, Region, TextEdgeBounds, TextElem, TextItem,
 };
 use typst_library::World;
 use typst_utils::SliceExt;
@@ -42,6 +41,8 @@ pub struct ShapedText<'a> {
     pub styles: StyleChain<'a>,
     /// The font variant.
     pub variant: FontVariant,
+    /// The font size.
+    pub size: Abs,
     /// The width of the text's bounding box.
     pub width: Abs,
     /// The shaped glyphs.
@@ -61,8 +62,6 @@ pub struct ShapedGlyph {
     pub x_offset: Em,
     /// The vertical offset of the glyph.
     pub y_offset: Em,
-    /// The font size for the glyph.
-    pub size: Abs,
     /// The adjustability of the glyph.
     pub adjustability: Adjustability,
     /// The byte range of this glyph's cluster in the full inline layout. A
@@ -223,17 +222,14 @@ impl<'a> ShapedText<'a> {
         let mut frame = Frame::soft(size);
         frame.set_baseline(top);
 
-        let size = TextElem::size_in(self.styles);
         let shift = TextElem::baseline_in(self.styles);
         let decos = TextElem::deco_in(self.styles);
         let fill = TextElem::fill_in(self.styles);
         let stroke = TextElem::stroke_in(self.styles);
         let span_offset = TextElem::span_offset_in(self.styles);
 
-        for ((font, y_offset, glyph_size), group) in self
+        for ((font, y_offset), group) in
-            .glyphs
+            self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset))
-            .as_ref()
-            .group_by_key(|g| (g.font.clone(), g.y_offset, g.size))
         {
             let mut range = group[0].range.clone();
             for glyph in group {
@@ -241,7 +237,7 @@ impl<'a> ShapedText<'a> {
                 range.end = range.end.max(glyph.range.end);
             }
 
-            let pos = Point::new(offset, top + shift - y_offset.at(size));
+            let pos = Point::new(offset, top + shift - y_offset.at(self.size));
             let glyphs: Vec<Glyph> = group
                 .iter()
                 .map(|shaped: &ShapedGlyph| {
@@ -261,11 +257,11 @@ impl<'a> ShapedText<'a> {
                         adjustability_right * justification_ratio;
                     if shaped.is_justifiable() {
                         justification_right +=
-                            Em::from_abs(extra_justification, glyph_size)
+                            Em::from_length(extra_justification, self.size)
                     }
 
-                    frame.size_mut().x += justification_left.at(glyph_size)
+                    frame.size_mut().x += justification_left.at(self.size)
-                        + justification_right.at(glyph_size);
+                        + justification_right.at(self.size);
 
                     // We may not be able to reach the offset completely if
                     // it exceeds u16, but better to have a roughly correct
@@ -308,7 +304,7 @@ impl<'a> ShapedText<'a> {
 
             let item = TextItem {
                 font,
-                size: glyph_size,
+                size: self.size,
                 lang: self.lang,
                 region: self.region,
                 fill: fill.clone(),
@@ -340,13 +336,12 @@ impl<'a> ShapedText<'a> {
         let mut top = Abs::zero();
         let mut bottom = Abs::zero();
 
-        let size = TextElem::size_in(self.styles);
         let top_edge = TextElem::top_edge_in(self.styles);
         let bottom_edge = TextElem::bottom_edge_in(self.styles);
 
         // Expand top and bottom by reading the font's vertical metrics.
         let mut expand = |font: &Font, bounds: TextEdgeBounds| {
-            let (t, b) = font.edges(top_edge, bottom_edge, size, bounds);
+            let (t, b) = font.edges(top_edge, bottom_edge, self.size, bounds);
             top.set_max(t);
             bottom.set_max(b);
         };
@@ -393,16 +388,18 @@ impl<'a> ShapedText<'a> {
     pub fn stretchability(&self) -> Abs {
         self.glyphs
             .iter()
-            .map(|g| (g.stretchability().0 + g.stretchability().1).at(g.size))
+            .map(|g| g.stretchability().0 + g.stretchability().1)
-            .sum()
+            .sum::<Em>()
+            .at(self.size)
     }
 
     /// The shrinkability of the text
     pub fn shrinkability(&self) -> Abs {
         self.glyphs
             .iter()
-            .map(|g| (g.shrinkability().0 + g.shrinkability().1).at(g.size))
+            .map(|g| g.shrinkability().0 + g.shrinkability().1)
-            .sum()
+            .sum::<Em>()
+            .at(self.size)
     }
 
     /// Reshape a range of the shaped text, reusing information from this
@@ -421,8 +418,9 @@ impl<'a> ShapedText<'a> {
                 lang: self.lang,
                 region: self.region,
                 styles: self.styles,
+                size: self.size,
                 variant: self.variant,
-                width: glyphs_width(glyphs),
+                width: glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(self.size),
                 glyphs: Cow::Borrowed(glyphs),
             }
         } else {
@@ -486,15 +484,13 @@ impl<'a> ShapedText<'a> {
             // that subtracting either of the endpoints by self.base doesn't
             // underflow. See <https://github.com/typst/typst/issues/2283>.
             .unwrap_or_else(|| self.base..self.base);
-            let size = TextElem::size_in(self.styles);
+            self.width += x_advance.at(self.size);
-            self.width += x_advance.at(size);
             let glyph = ShapedGlyph {
                 font,
                 glyph_id: glyph_id.0,
                 x_advance,
                 x_offset: Em::zero(),
                 y_offset: Em::zero(),
-                size,
                 adjustability: Adjustability::default(),
                 range,
                 safe_to_break: true,
@@ -670,7 +666,6 @@ fn shape<'a>(
     region: Option<Region>,
 ) -> ShapedText<'a> {
     let size = TextElem::size_in(styles);
-    let shift_settings = TextElem::shift_settings_in(styles);
     let mut ctx = ShapingContext {
         engine,
         size,
@@ -681,7 +676,6 @@ fn shape<'a>(
         features: features(styles),
         fallback: TextElem::fallback_in(styles),
         dir,
-        shift_settings,
     };
 
     if !text.is_empty() {
@@ -704,17 +698,12 @@ fn shape<'a>(
         region,
         styles,
         variant: ctx.variant,
-        width: glyphs_width(&ctx.glyphs),
+        size,
+        width: ctx.glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(size),
         glyphs: Cow::Owned(ctx.glyphs),
     }
 }
 
-/// Computes the width of a run of glyphs relative to the font size, accounting
-/// for their individual scaling factors and other font metrics.
-fn glyphs_width(glyphs: &[ShapedGlyph]) -> Abs {
-    glyphs.iter().map(|g| g.x_advance.at(g.size)).sum()
-}
-
 /// Holds shaping results and metadata common to all shaped segments.
 struct ShapingContext<'a, 'v> {
     engine: &'a Engine<'v>,
@@ -726,7 +715,6 @@ struct ShapingContext<'a, 'v> {
     features: Vec<rustybuzz::Feature>,
     fallback: bool,
     dir: Dir,
-    shift_settings: Option<ShiftSettings>,
 }
 
 /// Shape text with font fallback using the `families` iterator.
@@ -801,18 +789,6 @@ fn shape_segment<'a>(
     // text extraction.
     buffer.set_flags(BufferFlags::REMOVE_DEFAULT_IGNORABLES);
 
-    let (script_shift, script_compensation, scale, shift_feature) = ctx
-        .shift_settings
-        .map_or((Em::zero(), Em::zero(), Em::one(), None), |settings| {
-            determine_shift(text, &font, settings)
-        });
-
-    let has_shift_feature = shift_feature.is_some();
-    if let Some(feat) = shift_feature {
-        // Temporarily push the feature.
-        ctx.features.push(feat)
-    }
-
     // Prepare the shape plan. This plan depends on direction, script, language,
     // and features, but is independent from the text and can thus be memoized.
     let plan = create_shape_plan(
@@ -823,10 +799,6 @@ fn shape_segment<'a>(
         &ctx.features,
     );
 
-    if has_shift_feature {
-        ctx.features.pop();
-    }
-
     // Shape!
     let buffer = rustybuzz::shape_with_plan(font.rusty(), &plan, buffer);
     let infos = buffer.glyph_infos();
@@ -897,9 +869,8 @@ fn shape_segment<'a>(
                 glyph_id: info.glyph_id as u16,
                 // TODO: Don't ignore y_advance.
                 x_advance,
-                x_offset: font.to_em(pos[i].x_offset) + script_compensation,
+                x_offset: font.to_em(pos[i].x_offset),
-                y_offset: font.to_em(pos[i].y_offset) + script_shift,
+                y_offset: font.to_em(pos[i].y_offset),
-                size: scale.at(ctx.size),
                 adjustability: Adjustability::default(),
                 range: start..end,
                 safe_to_break: !info.unsafe_to_break(),
@@ -961,64 +932,6 @@ fn shape_segment<'a>(
     ctx.used.pop();
 }
 
-/// Returns a `(script_shift, script_compensation, scale, feature)` quadruplet
-/// describing how to produce scripts.
-///
-/// Those values determine how the rendered text should be transformed to
-/// display sub-/super-scripts. If the OpenType feature can be used, the
-/// rendered text should not be transformed in any way, and so those values are
-/// neutral (`(0, 0, 1, None)`). If scripts should be synthesized, those values
-/// determine how to transform the rendered text to display scripts as expected.
-fn determine_shift(
-    text: &str,
-    font: &Font,
-    settings: ShiftSettings,
-) -> (Em, Em, Em, Option<Feature>) {
-    settings
-        .typographic
-        .then(|| {
-            // If typographic scripts are enabled (i.e., we want to use the
-            // OpenType feature instead of synthesizing if possible), we add
-            // "subs"/"sups" to the feature list if supported by the font.
-            // In case of a problem, we just early exit
-            let gsub = font.rusty().tables().gsub?;
-            let subtable_index =
-                gsub.features.find(settings.kind.feature())?.lookup_indices.get(0)?;
-            let coverage = gsub
-                .lookups
-                .get(subtable_index)?
-                .subtables
-                .get::<SubstitutionSubtable>(0)?
-                .coverage();
-            text.chars()
-                .all(|c| {
-                    font.rusty().glyph_index(c).is_some_and(|i| coverage.contains(i))
-                })
-                .then(|| {
-                    // If we can use the OpenType feature, we can keep the text
-                    // as is.
-                    (
-                        Em::zero(),
-                        Em::zero(),
-                        Em::one(),
-                        Some(Feature::new(settings.kind.feature(), 1, ..)),
-                    )
-                })
-        })
-        // Reunite the cases where `typographic` is `false` or where using the
-        // OpenType feature would not work.
-        .flatten()
-        .unwrap_or_else(|| {
-            let script_metrics = settings.kind.read_metrics(font.metrics());
-            (
-                settings.shift.unwrap_or(script_metrics.vertical_offset),
-                script_metrics.horizontal_offset,
-                settings.size.unwrap_or(script_metrics.height),
-                None,
-            )
-        })
-}
-
 /// Create a shape plan.
 #[comemo::memoize]
 pub fn create_shape_plan(
@@ -1050,7 +963,6 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
             x_advance,
             x_offset: Em::zero(),
             y_offset: Em::zero(),
-            size: ctx.size,
             adjustability: Adjustability::default(),
             range: start..end,
             safe_to_break: true,
@@ -1073,8 +985,9 @@ fn shape_tofus(ctx: &mut ShapingContext, base: usize, text: &str, font: Font) {
 
 /// Apply tracking and spacing to the shaped glyphs.
 fn track_and_space(ctx: &mut ShapingContext) {
-    let tracking = Em::from_abs(TextElem::tracking_in(ctx.styles), ctx.size);
+    let tracking = Em::from_length(TextElem::tracking_in(ctx.styles), ctx.size);
-    let spacing = TextElem::spacing_in(ctx.styles).map(|abs| Em::from_abs(abs, ctx.size));
+    let spacing =
+        TextElem::spacing_in(ctx.styles).map(|abs| Em::from_length(abs, ctx.size));
 
     let mut glyphs = ctx.glyphs.iter_mut().peekable();
     while let Some(glyph) = glyphs.next() {

crates/typst-layout/src/math/fragment.rs

@@ -215,7 +215,7 @@ impl MathFragment {
                     &glyph.item.font,
                     GlyphId(glyph.item.glyphs[glyph_index].id),
                     corner,
-                    Em::from_abs(height, glyph.item.size),
+                    Em::from_length(height, glyph.item.size),
                 )
                 .unwrap_or_default()
                 .at(glyph.item.size)
@@ -767,8 +767,8 @@ fn assemble(
             advance += ratio * (max_overlap - min_overlap);
         }
         let (x, y) = match axis {
-            Axis::X => (Em::from_abs(advance, base.item.size), Em::zero()),
+            Axis::X => (Em::from_length(advance, base.item.size), Em::zero()),
-            Axis::Y => (Em::zero(), Em::from_abs(advance, base.item.size)),
+            Axis::Y => (Em::zero(), Em::from_length(advance, base.item.size)),
         };
         glyphs.push(Glyph {
             id: part.glyph_id.0,

crates/typst-library/src/foundations/array.rs

@@ -94,7 +94,7 @@ impl Array {
     }
 
     /// Iterate over references to the contained values.
-    pub fn iter(&self) -> std::slice::Iter<'_, Value> {
+    pub fn iter(&self) -> std::slice::Iter<Value> {
         self.0.iter()
     }
 
@@ -604,7 +604,7 @@ impl Array {
         Ok(acc)
     }
 
-    /// Calculates the product of all items (works for all types that can be
+    /// Calculates the product all items (works for all types that can be
     /// multiplied).
     #[func]
     pub fn product(

crates/typst-library/src/foundations/calc.rs

@@ -207,9 +207,9 @@ pub fn sqrt(
 /// ```
 #[func]
 pub fn root(
-    /// The expression to take the root of.
+    /// The expression to take the root of
     radicand: f64,
-    /// Which root of the radicand to take.
+    /// Which root of the radicand to take
     index: Spanned<i64>,
 ) -> SourceResult<f64> {
     if index.v == 0 {
@@ -317,7 +317,7 @@ pub fn asin(
 /// ```
 #[func(title = "Arccosine")]
 pub fn acos(
-    /// The number whose arccosine to calculate. Must be between -1 and 1.
+    /// The number whose arcsine to calculate. Must be between -1 and 1.
     value: Spanned<Num>,
 ) -> SourceResult<Angle> {
     let val = value.v.float();
@@ -387,7 +387,7 @@ pub fn cosh(
     value.cosh()
 }
 
-/// Calculates the hyperbolic tangent of a hyperbolic angle.
+/// Calculates the hyperbolic tangent of an hyperbolic angle.
 ///
 /// ```example
 /// #calc.tanh(0) \

crates/typst-library/src/foundations/dict.rs

@@ -114,7 +114,7 @@ impl Dict {
     }
 
     /// Iterate over pairs of references to the contained keys and values.
-    pub fn iter(&self) -> indexmap::map::Iter<'_, Str, Value> {
+    pub fn iter(&self) -> indexmap::map::Iter<Str, Value> {
         self.0.iter()
     }
 

crates/typst-library/src/layout/container.rs

@@ -497,8 +497,7 @@ mod callbacks {
 
     macro_rules! callback {
         ($name:ident = ($($param:ident: $param_ty:ty),* $(,)?) -> $ret:ty) => {
-            #[derive(Debug, Clone, Hash)]
+            #[derive(Debug, Clone, PartialEq, Hash)]
-            #[allow(clippy::derived_hash_with_manual_eq)]
             pub struct $name {
                 captured: Content,
                 f: fn(&Content, $($param_ty),*) -> $ret,
@@ -536,19 +535,6 @@ mod callbacks {
                     (self.f)(&self.captured, $($param),*)
                 }
             }
-
-            impl PartialEq for $name {
-                fn eq(&self, other: &Self) -> bool {
-                    // Comparing function pointers is problematic. Since for
-                    // each type of content, there is typically just one
-                    // callback, we skip it. It barely matters anyway since
-                    // getting into a comparison codepath for inline & block
-                    // elements containing callback bodies is close to
-                    // impossible (as these are generally generated in show
-                    // rules).
-                    self.captured.eq(&other.captured)
-                }
-            }
         };
     }
 

crates/typst-library/src/layout/em.rs

@@ -6,7 +6,7 @@ use ecow::EcoString;
 use typst_utils::{Numeric, Scalar};
 
 use crate::foundations::{cast, repr, Repr, Resolve, StyleChain, Value};
-use crate::layout::{Abs, Length};
+use crate::layout::Abs;
 use crate::text::TextElem;
 
 /// A length that is relative to the font size.
@@ -26,18 +26,18 @@ impl Em {
         Self(Scalar::ONE)
     }
 
-    /// Creates a font-relative length.
+    /// Create a font-relative length.
     pub const fn new(em: f64) -> Self {
         Self(Scalar::new(em))
     }
 
-    /// Creates an em length from font units at the given units per em.
+    /// Create an em length from font units at the given units per em.
     pub fn from_units(units: impl Into<f64>, units_per_em: f64) -> Self {
         Self(Scalar::new(units.into() / units_per_em))
     }
 
-    /// Creates an em length from an absolute length at the given font size.
+    /// Create an em length from a length at the given font size.
-    pub fn from_abs(length: Abs, font_size: Abs) -> Self {
+    pub fn from_length(length: Abs, font_size: Abs) -> Self {
         let result = length / font_size;
         if result.is_finite() {
             Self(Scalar::new(result))
@@ -46,11 +46,6 @@ impl Em {
         }
     }
 
-    /// Creates an em length from a length at the given font size.
-    pub fn from_length(length: Length, font_size: Abs) -> Em {
-        length.em + Self::from_abs(length.abs, font_size)
-    }
-
     /// The number of em units.
     pub const fn get(self) -> f64 {
         (self.0).get()
@@ -61,7 +56,7 @@ impl Em {
         Self::new(self.get().abs())
     }
 
-    /// Converts to an absolute length at the given font size.
+    /// Convert to an absolute length at the given font size.
     pub fn at(self, font_size: Abs) -> Abs {
         let resolved = font_size * self.get();
         if resolved.is_finite() {

crates/typst-library/src/layout/fragment.rs

@@ -47,12 +47,12 @@ impl Fragment {
     }
 
     /// Iterate over the contained frames.
-    pub fn iter(&self) -> std::slice::Iter<'_, Frame> {
+    pub fn iter(&self) -> std::slice::Iter<Frame> {
         self.0.iter()
     }
 
     /// Iterate over the contained frames.
-    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, Frame> {
+    pub fn iter_mut(&mut self) -> std::slice::IterMut<Frame> {
         self.0.iter_mut()
     }
 }

crates/typst-library/src/text/font/mod.rs

@@ -228,10 +228,6 @@ pub struct FontMetrics {
     pub underline: LineMetrics,
     /// Recommended metrics for an overline.
     pub overline: LineMetrics,
-    /// Metrics for subscripts, if provided by the font.
-    pub subscript: Option<ScriptMetrics>,
-    /// Metrics for superscripts, if provided by the font.
-    pub superscript: Option<ScriptMetrics>,
 }
 
 impl FontMetrics {
@@ -244,7 +240,6 @@ impl FontMetrics {
         let cap_height = ttf.capital_height().filter(|&h| h > 0).map_or(ascender, to_em);
         let x_height = ttf.x_height().filter(|&h| h > 0).map_or(ascender, to_em);
         let descender = to_em(ttf.typographic_descender().unwrap_or(ttf.descender()));
-
         let strikeout = ttf.strikeout_metrics();
         let underline = ttf.underline_metrics();
 
@@ -267,20 +262,6 @@ impl FontMetrics {
             thickness: underline.thickness,
         };
 
-        let subscript = ttf.subscript_metrics().map(|metrics| ScriptMetrics {
-            width: to_em(metrics.x_size),
-            height: to_em(metrics.y_size),
-            horizontal_offset: to_em(metrics.x_offset),
-            vertical_offset: -to_em(metrics.y_offset),
-        });
-
-        let superscript = ttf.superscript_metrics().map(|metrics| ScriptMetrics {
-            width: to_em(metrics.x_size),
-            height: to_em(metrics.y_size),
-            horizontal_offset: to_em(metrics.x_offset),
-            vertical_offset: to_em(metrics.y_offset),
-        });
-
         Self {
             units_per_em,
             ascender,
@@ -290,8 +271,6 @@ impl FontMetrics {
             strikethrough,
             underline,
             overline,
-            superscript,
-            subscript,
         }
     }
 
@@ -317,24 +296,6 @@ pub struct LineMetrics {
     pub thickness: Em,
 }
 
-/// Metrics for subscripts or superscripts.
-#[derive(Debug, Copy, Clone)]
-pub struct ScriptMetrics {
-    /// The width of those scripts, relative to the outer font size.
-    pub width: Em,
-    /// The height of those scripts, relative to the outer font size.
-    pub height: Em,
-    /// The horizontal (to the right) offset of those scripts, relative to the
-    /// outer font size.
-    ///
-    /// This is used for italic correction.
-    pub horizontal_offset: Em,
-    /// The vertical (to the top) offset of those scripts, relative to the outer font size.
-    ///
-    /// For superscripts, this is positive. For subscripts, this is negative.
-    pub vertical_offset: Em,
-}
-
 /// Identifies a vertical metric of a font.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
 pub enum VerticalFontMetric {

crates/typst-library/src/text/mod.rs

@@ -755,12 +755,6 @@ pub struct TextElem {
     #[internal]
     #[ghost]
     pub smallcaps: Option<Smallcaps>,
-
-    /// The configuration for superscripts or subscripts, if one of them is
-    /// enabled.
-    #[internal]
-    #[ghost]
-    pub shift_settings: Option<ShiftSettings>,
 }
 
 impl TextElem {
@@ -936,7 +930,7 @@ cast! {
 }
 
 /// Resolve a prioritized iterator over the font families.
-pub fn families(styles: StyleChain<'_>) -> impl Iterator<Item = &'_ FontFamily> + Clone {
+pub fn families(styles: StyleChain) -> impl Iterator<Item = &FontFamily> + Clone {
     let fallbacks = singleton!(Vec<FontFamily>, {
         [
             "libertinus serif",

crates/typst-library/src/text/shift.rs

@@ -1,13 +1,14 @@
+use ecow::EcoString;
+
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
+    elem, Content, NativeElement, Packed, SequenceElem, Show, StyleChain, TargetElem,
 };
 use crate::html::{tag, HtmlElem};
 use crate::layout::{Em, Length};
-use crate::text::{FontMetrics, TextElem, TextSize};
+use crate::text::{variant, SpaceElem, TextElem, TextSize};
-use ttf_parser::Tag;
+use crate::World;
-use typst_library::text::ScriptMetrics;
 
 /// Renders text in subscript.
 ///
@@ -19,16 +20,11 @@ use typst_library::text::ScriptMetrics;
 /// ```
 #[elem(title = "Subscript", Show)]
 pub struct SubElem {
-    /// Whether to create artificial subscripts by lowering and scaling down
+    /// Whether to prefer the dedicated subscript characters of the font.
-    /// regular glyphs.
     ///
-    /// Ideally, subscripts glyphs are provided by the font (using the `subs`
+    /// If this is enabled, Typst first tries to transform the text to subscript
-    /// OpenType feature). Otherwise, Typst is able to synthesize subscripts.
+    /// codepoints. If that fails, it falls back to rendering lowered and shrunk
-    ///
+    /// normal letters.
-    /// When this is set to `{false}`, synthesized glyphs will be used
-    /// regardless of whether the font provides dedicated subscript glyphs. When
-    /// `{true}`, synthesized glyphs may still be used in case the font does not
-    /// provide the necessary subscript glyphs.
     ///
     /// ```example
     /// N#sub(typographic: true)[1]
@@ -37,27 +33,17 @@ pub struct SubElem {
     #[default(true)]
     pub typographic: bool,
 
-    /// The downward baseline shift for synthesized subscripts.
+    /// The baseline shift for synthetic subscripts. Does not apply if
-    ///
+    /// `typographic` is true and the font has subscript codepoints for the
-    /// This only applies to synthesized subscripts. In other words, this has no
+    /// given `body`.
-    /// effect if `typographic` is `{true}` and the font provides the necessary
+    #[default(Em::new(0.2).into())]
-    /// subscript glyphs.
+    pub baseline: Length,
-    ///
-    /// If set to `{auto}`, the baseline is shifted according to the metrics
-    /// provided by the font, with a fallback to `{0.2em}` in case the font does
-    /// not define the necessary metrics.
-    pub baseline: Smart<Length>,
 
-    /// The font size for synthesized subscripts.
+    /// The font size for synthetic subscripts. Does not apply if
-    ///
+    /// `typographic` is true and the font has subscript codepoints for the
-    /// This only applies to synthesized subscripts. In other words, this has no
+    /// given `body`.
-    /// effect if `typographic` is `{true}` and the font provides the necessary
+    #[default(TextSize(Em::new(0.6).into()))]
-    /// subscript glyphs.
+    pub size: TextSize,
-    ///
-    /// If set to `{auto}`, the size is scaled according to the metrics provided
-    /// by the font, with a fallback to `{0.6em}` in case the font does not
-    /// define the necessary metrics.
-    pub size: Smart<TextSize>,
 
     /// The text to display in subscript.
     #[required]
@@ -66,7 +52,7 @@ pub struct SubElem {
 
 impl Show for Packed<SubElem> {
     #[typst_macros::time(name = "sub", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
         if TargetElem::target_in(styles).is_html() {
@@ -76,14 +62,17 @@ impl Show for Packed<SubElem> {
                 .spanned(self.span()));
         }
 
-        show_script(
+        if self.typographic(styles) {
-            styles,
+            if let Some(text) = convert_script(&body, true) {
-            body,
+                if is_shapable(engine, &text, styles) {
-            self.typographic(styles),
+                    return Ok(TextElem::packed(text));
-            self.baseline(styles),
+                }
-            self.size(styles),
+            }
-            ScriptKind::Sub,
+        };
-        )
+
+        Ok(body
+            .styled(TextElem::set_baseline(self.baseline(styles)))
+            .styled(TextElem::set_size(self.size(styles))))
     }
 }
 
@@ -97,16 +86,11 @@ impl Show for Packed<SubElem> {
 /// ```
 #[elem(title = "Superscript", Show)]
 pub struct SuperElem {
-    /// Whether to create artificial superscripts by raising and scaling down
+    /// Whether to prefer the dedicated superscript characters of the font.
-    /// regular glyphs.
     ///
-    /// Ideally, superscripts glyphs are provided by the font (using the `sups`
+    /// If this is enabled, Typst first tries to transform the text to
-    /// OpenType feature). Otherwise, Typst is able to synthesize superscripts.
+    /// superscript codepoints. If that fails, it falls back to rendering
-    ///
+    /// raised and shrunk normal letters.
-    /// When this is set to `{false}`, synthesized glyphs will be used
-    /// regardless of whether the font provides dedicated superscript glyphs.
-    /// When `{true}`, synthesized glyphs may still be used in case the font
-    /// does not provide the necessary superscript glyphs.
     ///
     /// ```example
     /// N#super(typographic: true)[1]
@@ -115,31 +99,17 @@ pub struct SuperElem {
     #[default(true)]
     pub typographic: bool,
 
-    /// The downward baseline shift for synthesized superscripts.
+    /// The baseline shift for synthetic superscripts. Does not apply if
-    ///
+    /// `typographic` is true and the font has superscript codepoints for the
-    /// This only applies to synthesized superscripts. In other words, this has
+    /// given `body`.
-    /// no effect if `typographic` is `{true}` and the font provides the
+    #[default(Em::new(-0.5).into())]
-    /// necessary superscript glyphs.
+    pub baseline: Length,
-    ///
-    /// If set to `{auto}`, the baseline is shifted according to the metrics
-    /// provided by the font, with a fallback to `{-0.5em}` in case the font
-    /// does not define the necessary metrics.
-    ///
-    /// Note that, since the baseline shift is applied downward, you will need
-    /// to provide a negative value for the content to appear as raised above
-    /// the normal baseline.
-    pub baseline: Smart<Length>,
 
-    /// The font size for synthesized superscripts.
+    /// The font size for synthetic superscripts. Does not apply if
-    ///
+    /// `typographic` is true and the font has superscript codepoints for the
-    /// This only applies to synthesized superscripts. In other words, this has
+    /// given `body`.
-    /// no effect if `typographic` is `{true}` and the font provides the
+    #[default(TextSize(Em::new(0.6).into()))]
-    /// necessary superscript glyphs.
+    pub size: TextSize,
-    ///
-    /// If set to `{auto}`, the size is scaled according to the metrics provided
-    /// by the font, with a fallback to `{0.6em}` in case the font does not
-    /// define the necessary metrics.
-    pub size: Smart<TextSize>,
 
     /// The text to display in superscript.
     #[required]
@@ -148,7 +118,7 @@ pub struct SuperElem {
 
 impl Show for Packed<SuperElem> {
     #[typst_macros::time(name = "super", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
         if TargetElem::target_in(styles).is_html() {
@@ -158,102 +128,104 @@ impl Show for Packed<SuperElem> {
                 .spanned(self.span()));
         }
 
-        show_script(
+        if self.typographic(styles) {
-            styles,
+            if let Some(text) = convert_script(&body, false) {
-            body,
+                if is_shapable(engine, &text, styles) {
-            self.typographic(styles),
+                    return Ok(TextElem::packed(text));
-            self.baseline(styles),
+                }
-            self.size(styles),
+            }
-            ScriptKind::Super,
+        };
-        )
+
+        Ok(body
+            .styled(TextElem::set_baseline(self.baseline(styles)))
+            .styled(TextElem::set_size(self.size(styles))))
     }
 }
 
-fn show_script(
+/// Find and transform the text contained in `content` to the given script kind
-    styles: StyleChain,
+/// if and only if it only consists of `Text`, `Space`, and `Empty` leaves.
-    body: Content,
+fn convert_script(content: &Content, sub: bool) -> Option<EcoString> {
-    typographic: bool,
+    if content.is::<SpaceElem>() {
-    baseline: Smart<Length>,
+        Some(' '.into())
-    size: Smart<TextSize>,
+    } else if let Some(elem) = content.to_packed::<TextElem>() {
-    kind: ScriptKind,
+        if sub {
-) -> SourceResult<Content> {
+            elem.text.chars().map(to_subscript_codepoint).collect()
-    let font_size = TextElem::size_in(styles);
+        } else {
-    Ok(body.styled(TextElem::set_shift_settings(Some(ShiftSettings {
+            elem.text.chars().map(to_superscript_codepoint).collect()
-        typographic,
-        shift: baseline.map(|l| -Em::from_length(l, font_size)),
-        size: size.map(|t| Em::from_length(t.0, font_size)),
-        kind,
-    }))))
-}
-
-/// Configuration values for sub- or superscript text.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct ShiftSettings {
-    /// Whether the OpenType feature should be used if possible.
-    pub typographic: bool,
-    /// The baseline shift of the script, relative to the outer text size.
-    ///
-    /// For superscripts, this is positive. For subscripts, this is negative. A
-    /// value of [`Smart::Auto`] indicates that the value should be obtained
-    /// from font metrics.
-    pub shift: Smart<Em>,
-    /// The size of the script, relative to the outer text size.
-    ///
-    /// A value of [`Smart::Auto`] indicates that the value should be obtained
-    /// from font metrics.
-    pub size: Smart<Em>,
-    /// The kind of script (either a subscript, or a superscript).
-    ///
-    /// This is used to know which OpenType table to use to resolve
-    /// [`Smart::Auto`] values.
-    pub kind: ScriptKind,
-}
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum ScriptKind {
-    Sub,
-    Super,
-}
-
-impl ScriptKind {
-    /// Returns the default metrics for this script kind.
-    ///
-    /// This can be used as a last resort if neither the user nor the font
-    /// provided those metrics.
-    pub fn default_metrics(self) -> &'static ScriptMetrics {
-        match self {
-            Self::Sub => &DEFAULT_SUBSCRIPT_METRICS,
-            Self::Super => &DEFAULT_SUPERSCRIPT_METRICS,
-        }
-    }
-
-    /// Reads the script metrics from the font table for to this script kind.
-    pub fn read_metrics(self, font_metrics: &FontMetrics) -> &ScriptMetrics {
-        match self {
-            Self::Sub => font_metrics.subscript.as_ref(),
-            Self::Super => font_metrics.superscript.as_ref(),
-        }
-        .unwrap_or(self.default_metrics())
-    }
-
-    /// The corresponding OpenType feature.
-    pub const fn feature(self) -> Tag {
-        match self {
-            Self::Sub => Tag::from_bytes(b"subs"),
-            Self::Super => Tag::from_bytes(b"sups"),
         }
+    } else if let Some(sequence) = content.to_packed::<SequenceElem>() {
+        sequence
+            .children
+            .iter()
+            .map(|item| convert_script(item, sub))
+            .collect()
+    } else {
+        None
     }
 }
-static DEFAULT_SUBSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
-    width: Em::new(0.6),
-    height: Em::new(0.6),
-    horizontal_offset: Em::zero(),
-    vertical_offset: Em::new(-0.2),
-};
 
-static DEFAULT_SUPERSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
+/// Checks whether the first retrievable family contains all code points of the
-    width: Em::new(0.6),
+/// given string.
-    height: Em::new(0.6),
+fn is_shapable(engine: &Engine, text: &str, styles: StyleChain) -> bool {
-    horizontal_offset: Em::zero(),
+    let world = engine.world;
-    vertical_offset: Em::new(0.5),
+    for family in TextElem::font_in(styles) {
-};
+        if let Some(font) = world
+            .book()
+            .select(family.as_str(), variant(styles))
+            .and_then(|id| world.font(id))
+        {
+            let covers = family.covers();
+            return text.chars().all(|c| {
+                covers.is_none_or(|cov| cov.is_match(c.encode_utf8(&mut [0; 4])))
+                    && font.ttf().glyph_index(c).is_some()
+            });
+        }
+    }
+
+    false
+}
+
+/// Convert a character to its corresponding Unicode superscript.
+fn to_superscript_codepoint(c: char) -> Option<char> {
+    match c {
+        '1' => Some('¹'),
+        '2' => Some('²'),
+        '3' => Some('³'),
+        '0' | '4'..='9' => char::from_u32(c as u32 - '0' as u32 + '⁰' as u32),
+        '+' => Some('⁺'),
+        '−' => Some('⁻'),
+        '=' => Some('⁼'),
+        '(' => Some('⁽'),
+        ')' => Some('⁾'),
+        'n' => Some('ⁿ'),
+        'i' => Some('ⁱ'),
+        ' ' => Some(' '),
+        _ => None,
+    }
+}
+
+/// Convert a character to its corresponding Unicode subscript.
+fn to_subscript_codepoint(c: char) -> Option<char> {
+    match c {
+        '0'..='9' => char::from_u32(c as u32 - '0' as u32 + '₀' as u32),
+        '+' => Some('₊'),
+        '−' => Some('₋'),
+        '=' => Some('₌'),
+        '(' => Some('₍'),
+        ')' => Some('₎'),
+        'a' => Some('ₐ'),
+        'e' => Some('ₑ'),
+        'o' => Some('ₒ'),
+        'x' => Some('ₓ'),
+        'h' => Some('ₕ'),
+        'k' => Some('ₖ'),
+        'l' => Some('ₗ'),
+        'm' => Some('ₘ'),
+        'n' => Some('ₙ'),
+        'p' => Some('ₚ'),
+        's' => Some('ₛ'),
+        't' => Some('ₜ'),
+        ' ' => Some(' '),
+        _ => None,
+    }
+}

crates/typst-pdf/src/metadata.rs

@@ -22,6 +22,8 @@ pub(crate) fn build_metadata(gc: &GlobalContext) -> Metadata {
         .keywords(gc.document.info.keywords.iter().map(EcoString::to_string).collect())
         .authors(gc.document.info.author.iter().map(EcoString::to_string).collect());
 
+    let lang = gc.languages.iter().max_by_key(|(_, &count)| count).map(|(&l, _)| l);
+
     if let Some(lang) = lang {
         metadata = metadata.language(lang.as_str().to_string());
     }

crates/typst-utils/src/lib.rs

@@ -395,10 +395,6 @@ pub fn default_math_class(c: char) -> Option<MathClass> {
         // https://github.com/typst/typst/issues/5764
         '⟇' => Some(MathClass::Binary),
 
-        // Arabic comma.
-        // https://github.com/latex3/unicode-math/pull/633#issuecomment-2028936135
-        '،' => Some(MathClass::Punctuation),
-
         c => unicode_math_class::class(c),
     }
 }

tests/suite/text/shift.typ

@@ -1,89 +1,22 @@
 // Test sub- and superscript shifts.
 
 --- sub-super ---
-#let sq = box(square(size: 4pt))
 #table(
   columns: 3,
-  [Typo.], [Fallb.], [Synth.],
+  [Typo.], [Fallb.], [Synth],
-  [x#super[1#sq]], [x#super[5: #sq]], [x#super(typographic: false)[2 #sq]],
+  [x#super[1]], [x#super[5n]], [x#super[2 #box(square(size: 6pt))]],
-  [x#sub[1#sq]], [x#sub[5: #sq]], [x#sub(typographic: false)[2 #sq]],
+  [x#sub[1]], [x#sub[5n]], [x#sub[2 #box(square(size: 6pt))]],
 )
 
---- sub-super-typographic ---
-#set text(size: 20pt)
-// Libertinus Serif supports "subs" and "sups" for `typo` and `sq`, but not for
-// `synth`.
-#let synth = [1,2,3]
-#let typo = [123]
-#let sq = [1#box(square(size: 4pt))2]
-x#super(synth) x#super(typo) x#super(sq) \
-x#sub(synth) x#sub(typo) x#sub(sq)
-
---- sub-super-italic-compensation ---
-#set text(size: 20pt, style: "italic")
-// Libertinus Serif supports "subs" and "sups" for `typo`, but not for `synth`.
-#let synth = [1,2,3]
-#let typo = [123]
-#let sq = [1#box(square(size: 4pt))2]
-x#super(synth) x#super(typo) x#super(sq) \
-x#sub(synth) x#sub(typo) x#sub(sq)
-
 --- sub-super-non-typographic ---
 #set super(typographic: false, baseline: -0.25em, size: 0.7em)
 n#super[1], n#sub[2], ... n#super[N]
 
 --- super-underline ---
 #set underline(stroke: 0.5pt, offset: 0.15em)
-#set super(typographic: false)
+#underline[The claim#super[\[4\]]] has been disputed. \
-#underline[A#super[4]] B \
+The claim#super[#underline[\[4\]]] has been disputed. \
-A#super[#underline[4]] B \
+It really has been#super(box(text(baseline: 0pt, underline[\[4\]]))) \
-A #underline(super[4]) B \
-#set super(typographic: true)
-#underline[A#super[4]] B \
-A#super[#underline[4]] B \
-A #underline(super[4]) B
-
---- super-highlight ---
-#set super(typographic: false)
-#highlight[A#super[4]] B \
-A#super[#highlight[4]] B \
-A#super(highlight[4]) \
-#set super(typographic: true)
-#highlight[A#super[4]] B \
-A#super[#highlight[4]] B \
-A#super(highlight[4])
-
---- super-1em ---
-#set text(size: 10pt)
-#super(context test(1em.to-absolute(), 10pt))
-
---- long-scripts ---
-|longscript| \
-|#super(typographic: true)[longscript]| \
-|#super(typographic: false)[longscript]| \
-|#sub(typographic: true)[longscript]| \
-|#sub(typographic: false)[longscript]|
-
---- script-metrics-bundeled-fonts ---
-// Tests whether the script metrics are used properly by synthesizing
-// superscripts and subscripts for all bundled fonts.
-
-#set super(typographic: false)
-#set sub(typographic: false)
-
-#let test(font, weights, styles) = {
-  for weight in weights {
-    for style in styles {
-      text(font: font, weight: weight, style: style)[Xx#super[Xx]#sub[Xx]]
-      linebreak()
-    }
-  }
-}
-
-#test("DejaVu Sans Mono", ("regular", "bold"), ("normal", "oblique"))
-#test("Libertinus Serif", ("regular", "semibold", "bold"), ("normal", "italic"))
-#test("New Computer Modern", ("regular", "bold"), ("normal", "italic"))
-#test("New Computer Modern Math", (400, 450, "bold"), ("normal",))
 
 --- basic-sup-sub html ---
 1#super[st], 2#super[nd], 3#super[rd].