WIP [no ci]

skip-checks:true

# Please enter the commit message for your changes. Lines starting
# with '#' will be kept; you may remove them yourself if you want to.
# An empty message aborts the commit.
#
# Date:      Wed May 28 17:47:35 2025 +0200
#
# On branch pdf-accessibility
# Your branch and 'origin/pdf-accessibility' have diverged,
# and have 11 and 5 different commits each, respectively.
#
# Changes to be committed:
#	modified:   crates/typst-ide/src/jump.rs
#	modified:   crates/typst-layout/src/flow/distribute.rs
#	modified:   crates/typst-layout/src/modifiers.rs
#	modified:   crates/typst-library/src/foundations/content.rs
#	modified:   crates/typst-library/src/layout/frame.rs
#	modified:   crates/typst-library/src/model/bibliography.rs
#	modified:   crates/typst-library/src/model/footnote.rs
#	modified:   crates/typst-library/src/model/link.rs
#	modified:   crates/typst-library/src/model/outline.rs
#	modified:   crates/typst-library/src/model/reference.rs
#	modified:   crates/typst-pdf/src/convert.rs
#	modified:   crates/typst-pdf/src/link.rs
#	modified:   crates/typst-render/src/lib.rs
#	modified:   crates/typst-svg/src/lib.rs
#	modified:   tests/src/run.rs
#

Cargo.lock

@@ -413,7 +413,7 @@ dependencies = [
 [[package]]
 name = "codex"
 version = "0.1.1"
-source = "git+https://github.com/typst/codex?rev=56eb217#56eb2172fc0670f4c1c8b79a63d11f9354e5babe"
+source = "git+https://github.com/typst/codex?rev=a5428cb#a5428cb9c81a41354d44b44dbd5a16a710bbd928"
 
 [[package]]
 name = "color-print"
@@ -2909,7 +2909,7 @@ dependencies = [
 [[package]]
 name = "typst-dev-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-dev-assets?rev=fddbf8b#fddbf8b99506bc370ac0edcd4959add603a7fc92"
+source = "git+https://github.com/typst/typst-dev-assets?rev=bfa947f#bfa947f3433d7d13a995168c40ae788a2ebfe648"
 
 [[package]]
 name = "typst-docs"

Cargo.toml

@@ -33,7 +33,7 @@ typst-syntax = { path = "crates/typst-syntax", version = "0.13.1" }
 typst-timing = { path = "crates/typst-timing", version = "0.13.1" }
 typst-utils = { path = "crates/typst-utils", version = "0.13.1" }
 typst-assets = { git = "https://github.com/typst/typst-assets", rev = "c1089b4" }
-typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "fddbf8b" }
+typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "bfa947f" }
 arrayvec = "0.7.4"
 az = "1.2"
 base64 = "0.22"
@@ -47,7 +47,7 @@ clap = { version = "4.4", features = ["derive", "env", "wrap_help"] }
 clap_complete = "4.2.1"
 clap_mangen = "0.2.10"
 codespan-reporting = "0.11"
-codex = { git = "https://github.com/typst/codex", rev = "56eb217" }
+codex = { git = "https://github.com/typst/codex", rev = "a5428cb" }
 color-print = "0.3.6"
 comemo = "0.4"
 csv = "1"

crates/typst-eval/src/markup.rs

@@ -205,7 +205,9 @@ impl Eval for ast::Label<'_> {
     type Output = Value;
 
     fn eval(self, _: &mut Vm) -> SourceResult<Self::Output> {
-        Ok(Value::Label(Label::new(PicoStr::intern(self.get()))))
+        Ok(Value::Label(
+            Label::new(PicoStr::intern(self.get())).expect("unexpected empty label"),
+        ))
     }
 }
 
@@ -213,7 +215,8 @@ impl Eval for ast::Ref<'_> {
     type Output = Content;
 
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
-        let target = Label::new(PicoStr::intern(self.target()));
+        let target = Label::new(PicoStr::intern(self.target()))
+            .expect("unexpected empty reference");
         let mut elem = RefElem::new(target);
         if let Some(supplement) = self.supplement() {
             elem.push_supplement(Smart::Custom(Some(Supplement::Content(

crates/typst-html/src/encode.rs

@@ -3,9 +3,8 @@ use std::fmt::Write;
 use typst_library::diag::{bail, At, SourceResult, StrResult};
 use typst_library::foundations::Repr;
 use typst_library::html::{
-    attr, charsets, tag, HtmlDocument, HtmlElement, HtmlNode, HtmlTag,
+    attr, charsets, tag, HtmlDocument, HtmlElement, HtmlFrame, HtmlNode, HtmlTag,
 };
-use typst_library::layout::Frame;
 use typst_syntax::Span;
 
 /// Encodes an HTML document into a string.
@@ -304,9 +303,15 @@ fn write_escape(w: &mut Writer, c: char) -> StrResult<()> {
 }
 
 /// Encode a laid out frame into the writer.
-fn write_frame(w: &mut Writer, frame: &Frame) {
+fn write_frame(w: &mut Writer, frame: &HtmlFrame) {
     // FIXME: This string replacement is obviously a hack.
-    let svg = typst_svg::svg_frame(frame)
+    let svg = typst_svg::svg_frame(&frame.inner).replace(
-        .replace("<svg class", "<svg style=\"overflow: visible;\" class");
+        "<svg class",
+        &format!(
+            "<svg style=\"overflow: visible; width: {}em; height: {}em;\" class",
+            frame.inner.width() / frame.text_size,
+            frame.inner.height() / frame.text_size,
+        ),
+    );
     w.buf.push_str(&svg);
 }

crates/typst-html/src/lib.rs

@@ -9,7 +9,7 @@ use typst_library::diag::{bail, warning, At, SourceResult};
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, StyleChain, Target, TargetElem};
 use typst_library::html::{
-    attr, tag, FrameElem, HtmlDocument, HtmlElem, HtmlElement, HtmlNode,
+    attr, tag, FrameElem, HtmlDocument, HtmlElem, HtmlElement, HtmlFrame, HtmlNode,
 };
 use typst_library::introspection::{
     Introspector, Locator, LocatorLink, SplitLocator, TagElem,
@@ -246,7 +246,10 @@ fn handle(
             styles.chain(&style),
             Region::new(Size::splat(Abs::inf()), Axes::splat(false)),
         )?;
-        output.push(HtmlNode::Frame(frame));
+        output.push(HtmlNode::Frame(HtmlFrame {
+            inner: frame,
+            text_size: TextElem::size_in(styles),
+        }));
     } else {
         engine.sink.warn(warning!(
             child.span(),

crates/typst-ide/src/complete.rs

@@ -448,7 +448,7 @@ fn field_access_completions(
     match value {
         Value::Symbol(symbol) => {
             for modifier in symbol.modifiers() {
-                if let Ok(modified) = symbol.clone().modified(modifier) {
+                if let Ok(modified) = symbol.clone().modified((), modifier) {
                     ctx.completions.push(Completion {
                         kind: CompletionKind::Symbol(modified.get()),
                         label: modifier.into(),

crates/typst-ide/src/definition.rs

@@ -72,7 +72,8 @@ pub fn definition(
 
         // Try to jump to the referenced content.
         DerefTarget::Ref(node) => {
-            let label = Label::new(PicoStr::intern(node.cast::<ast::Ref>()?.target()));
+            let label = Label::new(PicoStr::intern(node.cast::<ast::Ref>()?.target()))
+                .expect("unexpected empty reference");
             let selector = Selector::Label(label);
             let elem = document?.introspector.query_first(&selector)?;
             return Some(Definition::Span(elem.span()));

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

@@ -219,7 +219,7 @@ fn collect_items<'a>(
     // Add fallback text to expand the line height, if necessary.
     if !items.iter().any(|item| matches!(item, Item::Text(_))) {
         if let Some(fallback) = fallback {
-            items.push(fallback);
+            items.push(fallback, usize::MAX);
         }
     }
 
@@ -270,10 +270,10 @@ fn collect_range<'a>(
     items: &mut Items<'a>,
     fallback: &mut Option<ItemEntry<'a>>,
 ) {
-    for (subrange, item) in p.slice(range.clone()) {
+    for (idx, (subrange, item)) in p.slice(range.clone()).enumerate() {
         // All non-text items are just kept, they can't be split.
         let Item::Text(shaped) = item else {
-            items.push(item);
+            items.push(item, idx);
             continue;
         };
 
@@ -293,10 +293,10 @@ fn collect_range<'a>(
         } else if split {
             // When the item is split in half, reshape it.
             let reshaped = shaped.reshape(engine, sliced);
-            items.push(Item::Text(reshaped));
+            items.push(Item::Text(reshaped), idx);
         } else {
             // When the item is fully contained, just keep it.
-            items.push(item);
+            items.push(item, idx);
         }
     }
 }
@@ -499,16 +499,16 @@ pub fn commit(
 
     // Build the frames and determine the height and baseline.
     let mut frames = vec![];
-    for item in line.items.iter() {
+    for &(idx, ref item) in line.items.indexed_iter() {
-        let mut push = |offset: &mut Abs, frame: Frame| {
+        let mut push = |offset: &mut Abs, frame: Frame, idx: usize| {
             let width = frame.width();
             top.set_max(frame.baseline());
             bottom.set_max(frame.size().y - frame.baseline());
-            frames.push((*offset, frame));
+            frames.push((*offset, frame, idx));
             *offset += width;
         };
 
-        match item {
+        match &**item {
             Item::Absolute(v, _) => {
                 offset += *v;
             }
@@ -520,7 +520,7 @@ pub fn commit(
                         layout_box(elem, engine, loc.relayout(), styles, region)
                     })?;
                     apply_baseline_shift(&mut frame, *styles);
-                    push(&mut offset, frame);
+                    push(&mut offset, frame, idx);
                 } else {
                     offset += amount;
                 }
@@ -532,15 +532,15 @@ pub fn commit(
                     justification_ratio,
                     extra_justification,
                 );
-                push(&mut offset, frame);
+                push(&mut offset, frame, idx);
             }
             Item::Frame(frame) => {
-                push(&mut offset, frame.clone());
+                push(&mut offset, frame.clone(), idx);
             }
             Item::Tag(tag) => {
                 let mut frame = Frame::soft(Size::zero());
                 frame.push(Point::zero(), FrameItem::Tag((*tag).clone()));
-                frames.push((offset, frame));
+                frames.push((offset, frame, idx));
             }
             Item::Skip(_) => {}
         }
@@ -559,8 +559,13 @@ pub fn commit(
         add_par_line_marker(&mut output, marker, engine, locator, top);
     }
 
+    // Ensure that the final frame's items are in logical order rather than in
+    // visual order. This is important because it affects the order of elements
+    // during introspection and thus things like counters.
+    frames.sort_unstable_by_key(|(_, _, idx)| *idx);
+
     // Construct the line's frame.
-    for (offset, frame) in frames {
+    for (offset, frame, _) in frames {
         let x = offset + p.config.align.position(remaining);
         let y = top - frame.baseline();
         output.push_frame(Point::new(x, y), frame);
@@ -627,7 +632,7 @@ fn overhang(c: char) -> f64 {
 }
 
 /// A collection of owned or borrowed inline items.
-pub struct Items<'a>(Vec<ItemEntry<'a>>);
+pub struct Items<'a>(Vec<(usize, ItemEntry<'a>)>);
 
 impl<'a> Items<'a> {
     /// Create empty items.
@@ -636,33 +641,38 @@ impl<'a> Items<'a> {
     }
 
     /// Push a new item.
-    pub fn push(&mut self, entry: impl Into<ItemEntry<'a>>) {
+    pub fn push(&mut self, entry: impl Into<ItemEntry<'a>>, idx: usize) {
-        self.0.push(entry.into());
+        self.0.push((idx, entry.into()));
     }
 
-    /// Iterate over the items
+    /// Iterate over the items.
     pub fn iter(&self) -> impl Iterator<Item = &Item<'a>> {
-        self.0.iter().map(|item| &**item)
+        self.0.iter().map(|(_, item)| &**item)
+    }
+
+    /// Iterate over the items with indices
+    pub fn indexed_iter(&self) -> impl Iterator<Item = &(usize, ItemEntry<'a>)> {
+        self.0.iter()
     }
 
     /// Access the first item.
     pub fn first(&self) -> Option<&Item<'a>> {
-        self.0.first().map(|item| &**item)
+        self.0.first().map(|(_, item)| &**item)
     }
 
     /// Access the last item.
     pub fn last(&self) -> Option<&Item<'a>> {
-        self.0.last().map(|item| &**item)
+        self.0.last().map(|(_, item)| &**item)
     }
 
     /// Access the first item mutably, if it is text.
     pub fn first_text_mut(&mut self) -> Option<&mut ShapedText<'a>> {
-        self.0.first_mut()?.text_mut()
+        self.0.first_mut()?.1.text_mut()
     }
 
     /// Access the last item mutably, if it is text.
     pub fn last_text_mut(&mut self) -> Option<&mut ShapedText<'a>> {
-        self.0.last_mut()?.text_mut()
+        self.0.last_mut()?.1.text_mut()
     }
 
     /// Reorder the items starting at the given index to RTL.
@@ -673,12 +683,12 @@ impl<'a> Items<'a> {
 
 impl<'a> FromIterator<ItemEntry<'a>> for Items<'a> {
     fn from_iter<I: IntoIterator<Item = ItemEntry<'a>>>(iter: I) -> Self {
-        Self(iter.into_iter().collect())
+        Self(iter.into_iter().enumerate().collect())
     }
 }
 
 impl<'a> Deref for Items<'a> {
-    type Target = Vec<ItemEntry<'a>>;
+    type Target = Vec<(usize, ItemEntry<'a>)>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -698,6 +708,10 @@ impl Debug for Items<'_> {
 }
 
 /// A reference to or a boxed item.
+///
+/// This is conceptually similar to a [`Cow<'a, Item<'a>>`][std::borrow::Cow],
+/// but we box owned items since an [`Item`] is much bigger than
+/// a box.
 pub enum ItemEntry<'a> {
     Ref(&'a Item<'a>),
     Box(Box<Item<'a>>),

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

@@ -1,7 +1,8 @@
 use ecow::{eco_format, EcoString};
 use typst_utils::{PicoStr, ResolvedPicoStr};
 
-use crate::foundations::{func, scope, ty, Repr, Str};
+use crate::diag::StrResult;
+use crate::foundations::{bail, func, scope, ty, Repr, Str};
 
 /// A label for an element.
 ///
@@ -27,7 +28,8 @@ use crate::foundations::{func, scope, ty, Repr, Str};
 /// # Syntax
 /// This function also has dedicated syntax: You can create a label by enclosing
 /// its name in angle brackets. This works both in markup and code. A label's
-/// name can contain letters, numbers, `_`, `-`, `:`, and `.`.
+/// name can contain letters, numbers, `_`, `-`, `:`, and `.`. A label cannot
+/// be empty.
 ///
 /// Note that there is a syntactical difference when using the dedicated syntax
 /// for this function. In the code below, the `[<a>]` terminates the heading and
@@ -50,8 +52,11 @@ pub struct Label(PicoStr);
 
 impl Label {
     /// Creates a label from an interned string.
-    pub fn new(name: PicoStr) -> Self {
+    ///
-        Self(name)
+    /// Returns `None` if the given string is empty.
+    pub fn new(name: PicoStr) -> Option<Self> {
+        const EMPTY: PicoStr = PicoStr::constant("");
+        (name != EMPTY).then_some(Self(name))
     }
 
     /// Resolves the label to a string.
@@ -70,10 +75,14 @@ impl Label {
     /// Creates a label from a string.
     #[func(constructor)]
     pub fn construct(
-        /// The name of the label.
+        /// The name of the label. Must not be empty.
         name: Str,
-    ) -> Label {
+    ) -> StrResult<Label> {
-        Self(PicoStr::intern(name.as_str()))
+        if name.is_empty() {
+            bail!("label name must not be empty");
+        }
+
+        Ok(Self(PicoStr::intern(name.as_str())))
     }
 }
 

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

@@ -19,11 +19,8 @@ use crate::foundations::{repr, ty, Content, Scope, Value};
 ///
 /// You can access definitions from the module using [field access
 /// notation]($scripting/#fields) and interact with it using the [import and
-/// include syntaxes]($scripting/#modules). Alternatively, it is possible to
+/// include syntaxes]($scripting/#modules).
-/// convert a module to a dictionary, and therefore access its contents
-/// dynamically, using the [dictionary constructor]($dictionary/#constructor).
 ///
-/// # Example
 /// ```example
 /// <<< #import "utils.typ"
 /// <<< #utils.add(2, 5)
@@ -34,6 +31,20 @@ use crate::foundations::{repr, ty, Content, Scope, Value};
 /// >>>
 /// >>> #(-3)
 /// ```
+///
+/// You can check whether a definition is present in a module using the `{in}`
+/// operator, with a string on the left-hand side. This can be useful to
+/// [conditionally access]($category/foundations/std/#conditional-access)
+/// definitions in a module.
+///
+/// ```example
+/// #("table" in std) \
+/// #("nope" in std)
+/// ```
+///
+/// Alternatively, it is possible to convert a module to a dictionary, and
+/// therefore access its contents dynamically, using the [dictionary
+/// constructor]($dictionary/#constructor).
 #[ty(cast)]
 #[derive(Clone, Hash)]
 #[allow(clippy::derived_hash_with_manual_eq)]

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

@@ -558,6 +558,7 @@ pub fn contains(lhs: &Value, rhs: &Value) -> Option<bool> {
         (Str(a), Str(b)) => Some(b.as_str().contains(a.as_str())),
         (Dyn(a), Str(b)) => a.downcast::<Regex>().map(|regex| regex.is_match(b)),
         (Str(a), Dict(b)) => Some(b.contains(a)),
+        (Str(a), Module(b)) => Some(b.scope().get(a).is_some()),
         (a, Array(b)) => Some(b.contains(a.clone())),
 
         _ => Option::None,

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

@@ -8,7 +8,7 @@ use serde::{Serialize, Serializer};
 use typst_syntax::{is_ident, Span, Spanned};
 use typst_utils::hash128;
 
-use crate::diag::{bail, SourceResult, StrResult};
+use crate::diag::{bail, DeprecationSink, SourceResult, StrResult};
 use crate::foundations::{
     cast, elem, func, scope, ty, Array, Content, Func, NativeElement, NativeFunc, Packed,
     PlainText, Repr as _,
@@ -54,18 +54,22 @@ enum Repr {
     /// A native symbol that has no named variant.
     Single(char),
     /// A native symbol with multiple named variants.
-    Complex(&'static [(ModifierSet<&'static str>, char)]),
+    Complex(&'static [Variant<&'static str>]),
     /// A symbol with multiple named variants, where some modifiers may have
     /// been applied. Also used for symbols defined at runtime by the user with
     /// no modifier applied.
     Modified(Arc<(List, ModifierSet<EcoString>)>),
 }
 
+/// A symbol variant, consisting of a set of modifiers, a character, and an
+/// optional deprecation message.
+type Variant<S> = (ModifierSet<S>, char, Option<S>);
+
 /// A collection of symbols.
 #[derive(Clone, Eq, PartialEq, Hash)]
 enum List {
-    Static(&'static [(ModifierSet<&'static str>, char)]),
+    Static(&'static [Variant<&'static str>]),
-    Runtime(Box<[(ModifierSet<EcoString>, char)]>),
+    Runtime(Box<[Variant<EcoString>]>),
 }
 
 impl Symbol {
@@ -76,14 +80,14 @@ impl Symbol {
 
     /// Create a symbol with a static variant list.
     #[track_caller]
-    pub const fn list(list: &'static [(ModifierSet<&'static str>, char)]) -> Self {
+    pub const fn list(list: &'static [Variant<&'static str>]) -> Self {
         debug_assert!(!list.is_empty());
         Self(Repr::Complex(list))
     }
 
     /// Create a symbol with a runtime variant list.
     #[track_caller]
-    pub fn runtime(list: Box<[(ModifierSet<EcoString>, char)]>) -> Self {
+    pub fn runtime(list: Box<[Variant<EcoString>]>) -> Self {
         debug_assert!(!list.is_empty());
         Self(Repr::Modified(Arc::new((List::Runtime(list), ModifierSet::default()))))
     }
@@ -93,9 +97,11 @@ impl Symbol {
         match &self.0 {
             Repr::Single(c) => *c,
             Repr::Complex(_) => ModifierSet::<&'static str>::default()
-                .best_match_in(self.variants())
+                .best_match_in(self.variants().map(|(m, c, _)| (m, c)))
                 .unwrap(),
-            Repr::Modified(arc) => arc.1.best_match_in(self.variants()).unwrap(),
+            Repr::Modified(arc) => {
+                arc.1.best_match_in(self.variants().map(|(m, c, _)| (m, c))).unwrap()
+            }
         }
     }
 
@@ -128,7 +134,11 @@ impl Symbol {
     }
 
     /// Apply a modifier to the symbol.
-    pub fn modified(mut self, modifier: &str) -> StrResult<Self> {
+    pub fn modified(
+        mut self,
+        sink: impl DeprecationSink,
+        modifier: &str,
+    ) -> StrResult<Self> {
         if let Repr::Complex(list) = self.0 {
             self.0 =
                 Repr::Modified(Arc::new((List::Static(list), ModifierSet::default())));
@@ -137,7 +147,12 @@ impl Symbol {
         if let Repr::Modified(arc) = &mut self.0 {
             let (list, modifiers) = Arc::make_mut(arc);
             modifiers.insert_raw(modifier);
-            if modifiers.best_match_in(list.variants()).is_some() {
+            if let Some(deprecation) =
+                modifiers.best_match_in(list.variants().map(|(m, _, d)| (m, d)))
+            {
+                if let Some(message) = deprecation {
+                    sink.emit(message)
+                }
                 return Ok(self);
             }
         }
@@ -146,7 +161,7 @@ impl Symbol {
     }
 
     /// The characters that are covered by this symbol.
-    pub fn variants(&self) -> impl Iterator<Item = (ModifierSet<&str>, char)> {
+    pub fn variants(&self) -> impl Iterator<Item = Variant<&str>> {
         match &self.0 {
             Repr::Single(c) => Variants::Single(Some(*c).into_iter()),
             Repr::Complex(list) => Variants::Static(list.iter()),
@@ -161,7 +176,7 @@ impl Symbol {
             _ => ModifierSet::default(),
         };
         self.variants()
-            .flat_map(|(m, _)| m)
+            .flat_map(|(m, _, _)| m)
             .filter(|modifier| !modifier.is_empty() && !modifiers.contains(modifier))
             .collect::<BTreeSet<_>>()
             .into_iter()
@@ -256,7 +271,7 @@ impl Symbol {
 
         let list = variants
             .into_iter()
-            .map(|s| (ModifierSet::from_raw_dotted(s.v.0), s.v.1))
+            .map(|s| (ModifierSet::from_raw_dotted(s.v.0), s.v.1, None))
             .collect();
         Ok(Symbol::runtime(list))
     }
@@ -316,17 +331,17 @@ impl crate::foundations::Repr for Symbol {
 }
 
 fn repr_variants<'a>(
-    variants: impl Iterator<Item = (ModifierSet<&'a str>, char)>,
+    variants: impl Iterator<Item = Variant<&'a str>>,
     applied_modifiers: ModifierSet<&str>,
 ) -> String {
     crate::foundations::repr::pretty_array_like(
         &variants
-            .filter(|(modifiers, _)| {
+            .filter(|(modifiers, _, _)| {
                 // Only keep variants that can still be accessed, i.e., variants
                 // that contain all applied modifiers.
                 applied_modifiers.iter().all(|am| modifiers.contains(am))
             })
-            .map(|(modifiers, c)| {
+            .map(|(modifiers, c, _)| {
                 let trimmed_modifiers =
                     modifiers.into_iter().filter(|&m| !applied_modifiers.contains(m));
                 if trimmed_modifiers.clone().all(|m| m.is_empty()) {
@@ -379,18 +394,20 @@ cast! {
 /// Iterator over variants.
 enum Variants<'a> {
     Single(std::option::IntoIter<char>),
-    Static(std::slice::Iter<'static, (ModifierSet<&'static str>, char)>),
+    Static(std::slice::Iter<'static, Variant<&'static str>>),
-    Runtime(std::slice::Iter<'a, (ModifierSet<EcoString>, char)>),
+    Runtime(std::slice::Iter<'a, Variant<EcoString>>),
 }
 
 impl<'a> Iterator for Variants<'a> {
-    type Item = (ModifierSet<&'a str>, char);
+    type Item = Variant<&'a str>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self {
-            Self::Single(iter) => Some((ModifierSet::default(), iter.next()?)),
+            Self::Single(iter) => Some((ModifierSet::default(), iter.next()?, None)),
             Self::Static(list) => list.next().copied(),
-            Self::Runtime(list) => list.next().map(|(m, c)| (m.as_deref(), *c)),
+            Self::Runtime(list) => {
+                list.next().map(|(m, c, d)| (m.as_deref(), *c, d.as_deref()))
+            }
         }
     }
 }

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

@@ -157,7 +157,9 @@ impl Value {
     /// Try to access a field on the value.
     pub fn field(&self, field: &str, sink: impl DeprecationSink) -> StrResult<Value> {
         match self {
-            Self::Symbol(symbol) => symbol.clone().modified(field).map(Self::Symbol),
+            Self::Symbol(symbol) => {
+                symbol.clone().modified(sink, field).map(Self::Symbol)
+            }
             Self::Version(version) => version.component(field).map(Self::Int),
             Self::Dict(dict) => dict.get(field).cloned(),
             Self::Content(content) => content.field_by_name(field),

crates/typst-library/src/html/dom.rs

@@ -7,7 +7,7 @@ use typst_utils::{PicoStr, ResolvedPicoStr};
 use crate::diag::{bail, HintedStrResult, StrResult};
 use crate::foundations::{cast, Dict, Repr, Str};
 use crate::introspection::{Introspector, Tag};
-use crate::layout::Frame;
+use crate::layout::{Abs, Frame};
 use crate::model::DocumentInfo;
 
 /// An HTML document.
@@ -30,8 +30,8 @@ pub enum HtmlNode {
     Text(EcoString, Span),
     /// Another element.
     Element(HtmlElement),
-    /// A frame that will be displayed as an embedded SVG.
+    /// Layouted content that will be embedded into HTML as an SVG.
-    Frame(Frame),
+    Frame(HtmlFrame),
 }
 
 impl HtmlNode {
@@ -263,6 +263,17 @@ cast! {
     v: Str => Self::intern(&v)?,
 }
 
+/// Layouted content that will be embedded into HTML as an SVG.
+#[derive(Debug, Clone, Hash)]
+pub struct HtmlFrame {
+    /// The frame that will be displayed as an SVG.
+    pub inner: Frame,
+    /// The text size where the frame was defined. This is used to size the
+    /// frame with em units to make text in and outside of the frame sized
+    /// consistently.
+    pub text_size: Abs,
+}
+
 /// Defines syntactical properties of HTML tags, attributes, and text.
 pub mod charsets {
     /// Check whether a character is in a tag name.

crates/typst-library/src/introspection/introspector.rs

@@ -446,7 +446,7 @@ impl IntrospectorBuilder {
                 HtmlNode::Element(elem) => self.discover_in_html(sink, &elem.children),
                 HtmlNode::Frame(frame) => self.discover_in_frame(
                     sink,
-                    frame,
+                    &frame.inner,
                     NonZeroUsize::ONE,
                     Transform::identity(),
                 ),

crates/typst-library/src/layout/grid/resolve.rs

@@ -22,6 +22,7 @@ use typst_syntax::Span;
 use typst_utils::NonZeroExt;
 
 use crate::introspection::SplitLocator;
+use crate::model::TableCellKind;
 
 /// Convert a grid to a cell grid.
 #[typst_macros::time(span = elem.span())]
@@ -217,6 +218,7 @@ impl ResolvableCell for Packed<TableCell> {
         breakable: bool,
         locator: Locator<'a>,
         styles: StyleChain,
+        kind: Smart<TableCellKind>,
     ) -> Cell<'a> {
         let cell = &mut *self;
         let colspan = cell.colspan(styles);
@@ -224,6 +226,8 @@ impl ResolvableCell for Packed<TableCell> {
         let breakable = cell.breakable(styles).unwrap_or(breakable);
         let fill = cell.fill(styles).unwrap_or_else(|| fill.clone());
 
+        let kind = cell.kind(styles).or(kind);
+
         let cell_stroke = cell.stroke(styles);
         let stroke_overridden =
             cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_))));
@@ -267,6 +271,7 @@ impl ResolvableCell for Packed<TableCell> {
             }),
         );
         cell.push_breakable(Smart::Custom(breakable));
+        cell.push_kind(kind);
         Cell {
             body: self.pack(),
             locator,
@@ -312,6 +317,7 @@ impl ResolvableCell for Packed<GridCell> {
         breakable: bool,
         locator: Locator<'a>,
         styles: StyleChain,
+        _: Smart<TableCellKind>,
     ) -> Cell<'a> {
         let cell = &mut *self;
         let colspan = cell.colspan(styles);
@@ -522,6 +528,7 @@ pub trait ResolvableCell {
         breakable: bool,
         locator: Locator<'a>,
         styles: StyleChain,
+        kind: Smart<TableCellKind>,
     ) -> Cell<'a>;
 
     /// Returns this cell's column override.
@@ -1206,8 +1213,12 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         // a non-empty row.
         let mut first_available_row = 0;
 
+        let mut cell_kind: Smart<TableCellKind> = Smart::Auto;
+
         let (header_footer_items, simple_item) = match child {
             ResolvableGridChild::Header { repeat, level, span, items, .. } => {
+                cell_kind = Smart::Custom(TableCellKind::Header);
+
                 row_group_data = Some(RowGroupData {
                     range: None,
                     span,
@@ -1239,6 +1250,8 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                     bail!(span, "cannot have more than one footer");
                 }
 
+                cell_kind = Smart::Custom(TableCellKind::Footer);
+
                 row_group_data = Some(RowGroupData {
                     range: None,
                     span,
@@ -1447,7 +1460,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
 
             // Let's resolve the cell so it can determine its own fields
             // based on its final position.
-            let cell = self.resolve_cell(cell, x, y, rowspan, cell_span)?;
+            let cell = self.resolve_cell(cell, x, y, rowspan, cell_span, cell_kind)?;
 
             if largest_index >= resolved_cells.len() {
                 // Ensure the length of the vector of resolved cells is
@@ -1542,6 +1555,10 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                     // and footers without having to loop through them each time.
                     // Cells themselves, unfortunately, still have to.
                     assert!(resolved_cells[*local_auto_index].is_none());
+                    let kind = match row_group.kind {
+                        RowGroupKind::Header => TableCellKind::Header,
+                        RowGroupKind::Footer => TableCellKind::Header,
+                    };
                     resolved_cells[*local_auto_index] =
                         Some(Entry::Cell(self.resolve_cell(
                             T::default(),
@@ -1549,6 +1566,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                             first_available_row,
                             1,
                             Span::detached(),
+                            Smart::Custom(kind),
                         )?));
 
                     group_start..group_end
@@ -1673,6 +1691,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
                         y,
                         1,
                         Span::detached(),
+                        Smart::Auto,
                     )?))
                 }
             })
@@ -1918,6 +1937,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
         y: usize,
         rowspan: usize,
         cell_span: Span,
+        kind: Smart<TableCellKind>,
     ) -> SourceResult<Cell<'x>>
     where
         T: ResolvableCell + Default,
@@ -1954,6 +1974,7 @@ impl<'x> CellGridResolver<'_, '_, 'x> {
             breakable,
             self.locator.next(&cell_span),
             self.styles,
+            kind,
         ))
     }
 }

crates/typst-library/src/model/bibliography.rs

@@ -321,7 +321,11 @@ impl Bibliography {
         for d in data.iter() {
             let library = decode_library(d)?;
             for entry in library {
-                match map.entry(Label::new(PicoStr::intern(entry.key()))) {
+                let label = Label::new(PicoStr::intern(entry.key()))
+                    .ok_or("bibliography contains entry with empty key")
+                    .at(d.source.span)?;
+
+                match map.entry(label) {
                     indexmap::map::Entry::Vacant(vacant) => {
                         vacant.insert(entry);
                     }
@@ -592,7 +596,7 @@ impl Works {
 
 /// Context for generating the bibliography.
 struct Generator<'a> {
-    /// The routines that is used to evaluate mathematical material in citations.
+    /// The routines that are used to evaluate mathematical material in citations.
     routines: &'a Routines,
     /// The world that is used to evaluate mathematical material in citations.
     world: Tracked<'a, dyn World + 'a>,
@@ -609,7 +613,7 @@ struct Generator<'a> {
 
 /// Details about a group of merged citations. All citations are put into groups
 /// of adjacent ones (e.g., `@foo @bar` will merge into a group of length two).
-/// Even single citations will be put into groups of length ones.
+/// Even single citations will be put into groups of length one.
 struct GroupInfo {
     /// The group's location.
     location: Location,

crates/typst-library/src/model/table.rs

@@ -362,40 +362,15 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
 
 impl Show for Packed<TableElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let elem = if TargetElem::target_in(styles).is_html() {
+        Ok(if TargetElem::target_in(styles).is_html() {
             // TODO: This is a hack, it is not clear whether the locator is actually used by HTML.
             // How can we find out whether locator is actually used?
             let locator = Locator::root();
             show_cellgrid_html(table_to_cellgrid(self, engine, locator, styles)?, styles)
         } else {
-            let children = self
+            BlockElem::multi_layouter(self.clone(), engine.routines.layout_table).pack()
-                .children
+        }
-                .iter()
+        .spanned(self.span()))
-                .map(|c| match c.clone() {
-                    TableChild::Header(header) => {
-                        let mut header = header.unpack();
-                        header.children = header
-                            .children
-                            .into_iter()
-                            .map(|item| match item {
-                                TableItem::Cell(cell) => {
-                                    let mut cell = cell.unpack();
-                                    cell.push_header_scope(Smart::Custom(TableHeaderScope::Column));
-                                    TableItem::Cell(Packed::new(cell))
-                                }
-                                item => item,
-                            })
-                            .collect();
-                        TableChild::Header(Packed::new(header))
-                    }
-                    child => child,
-                })
-                .collect();
-            let mut table = self.clone().unpack();
-            table.children = children;
-            BlockElem::multi_layouter(Packed::new(table), engine.routines.layout_table).pack()
-        };
-        Ok(elem.spanned(self.span()))
     }
 }
 
@@ -836,6 +811,9 @@ pub struct TableCell {
     #[fold]
     pub stroke: Sides<Option<Option<Arc<Stroke>>>>,
 
+    // TODO: feature gate
+    pub kind: Smart<TableCellKind>,
+
     // TODO: feature gate
     pub header_scope: Smart<TableHeaderScope>,
 
@@ -883,3 +861,11 @@ pub enum TableHeaderScope {
     Column,
     Row,
 }
+
+#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Cast)]
+pub enum TableCellKind {
+    Header,
+    Footer,
+    #[default]
+    Data,
+}

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

@@ -2,7 +2,10 @@ use smallvec::smallvec;
 
 use crate::diag::SourceResult;
 use crate::engine::Engine;
-use crate::foundations::{elem, Content, Packed, Show, Smart, StyleChain};
+use crate::foundations::{
+    elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
+};
+use crate::html::{attr, tag, HtmlElem};
 use crate::introspection::Locatable;
 use crate::layout::{Abs, Corners, Length, Rel, Sides};
 use crate::text::{BottomEdge, BottomEdgeMetric, TextElem, TopEdge, TopEdgeMetric};
@@ -82,6 +85,16 @@ pub struct UnderlineElem {
 impl Show for Packed<UnderlineElem> {
     #[typst_macros::time(name = "underline", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        if TargetElem::target_in(styles).is_html() {
+            // Note: In modern HTML, `<u>` is not the underline element, but
+            // rather an "Unarticulated Annotation" element (see HTML spec
+            // 4.5.22). Using `text-decoration` instead is recommended by MDN.
+            return Ok(HtmlElem::new(tag::span)
+                .with_attr(attr::style, "text-decoration: underline")
+                .with_body(Some(self.body.clone()))
+                .pack());
+        }
+
         Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
             line: DecoLine::Underline {
                 stroke: self.stroke(styles).unwrap_or_default(),
@@ -174,6 +187,13 @@ pub struct OverlineElem {
 impl Show for Packed<OverlineElem> {
     #[typst_macros::time(name = "overline", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        if TargetElem::target_in(styles).is_html() {
+            return Ok(HtmlElem::new(tag::span)
+                .with_attr(attr::style, "text-decoration: overline")
+                .with_body(Some(self.body.clone()))
+                .pack());
+        }
+
         Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
             line: DecoLine::Overline {
                 stroke: self.stroke(styles).unwrap_or_default(),
@@ -251,6 +271,10 @@ pub struct StrikeElem {
 impl Show for Packed<StrikeElem> {
     #[typst_macros::time(name = "strike", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        if TargetElem::target_in(styles).is_html() {
+            return Ok(HtmlElem::new(tag::s).with_body(Some(self.body.clone())).pack());
+        }
+
         Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
             // Note that we do not support evade option for strikethrough.
             line: DecoLine::Strikethrough {
@@ -346,6 +370,12 @@ pub struct HighlightElem {
 impl Show for Packed<HighlightElem> {
     #[typst_macros::time(name = "highlight", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+        if TargetElem::target_in(styles).is_html() {
+            return Ok(HtmlElem::new(tag::mark)
+                .with_body(Some(self.body.clone()))
+                .pack());
+        }
+
         Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
             line: DecoLine::Highlight {
                 fill: self.fill(styles),

crates/typst-library/src/visualize/gradient.rs

@@ -1285,24 +1285,17 @@ fn process_stops(stops: &[Spanned<GradientStop>]) -> SourceResult<Vec<(Color, Ra
 /// Sample the stops at a given position.
 fn sample_stops(stops: &[(Color, Ratio)], mixing_space: ColorSpace, t: f64) -> Color {
     let t = t.clamp(0.0, 1.0);
-    let mut low = 0;
+    let mut j = stops.partition_point(|(_, ratio)| ratio.get() < t);
-    let mut high = stops.len();
 
-    while low < high {
+    if j == 0 {
-        let mid = (low + high) / 2;
+        while stops.get(j + 1).is_some_and(|(_, r)| r.is_zero()) {
-        if stops[mid].1.get() < t {
+            j += 1;
-            low = mid + 1;
-        } else {
-            high = mid;
         }
+        return stops[j].0;
     }
 
-    if low == 0 {
+    let (col_0, pos_0) = stops[j - 1];
-        low = 1;
+    let (col_1, pos_1) = stops[j];
-    }
-
-    let (col_0, pos_0) = stops[low - 1];
-    let (col_1, pos_1) = stops[low];
     let t = (t - pos_0.get()) / (pos_1.get() - pos_0.get());
 
     Color::mix_iter(

crates/typst-pdf/src/tags.rs

@@ -1,4 +1,5 @@
 use std::cell::OnceCell;
+use std::num::{NonZeroU32, NonZeroUsize};
 
 use ecow::EcoString;
 use krilla::page::Page;
@@ -7,12 +8,12 @@ use krilla::tagging::{
     ArtifactType, ContentTag, Identifier, Node, SpanTag, TableCellSpan, TableDataCell,
     TableHeaderCell, Tag, TagBuilder, TagGroup, TagKind, TagTree,
 };
-use typst_library::foundations::{Content, LinkMarker, Packed, StyleChain, Smart};
+use typst_library::foundations::{Content, LinkMarker, Packed, Smart, StyleChain};
 use typst_library::introspection::Location;
 use typst_library::layout::RepeatElem;
 use typst_library::model::{
     Destination, FigureCaption, FigureElem, HeadingElem, Outlinable, OutlineBody,
-    OutlineEntry, TableCell, TableElem, TableHeaderScope,
+    OutlineEntry, TableCell, TableCellKind, TableElem, TableHeaderScope,
 };
 use typst_library::pdf::{ArtifactElem, ArtifactKind, PdfTagElem, PdfTagKind};
 use typst_library::visualize::ImageElem;
@@ -125,7 +126,42 @@ impl OutlineCtx {
 
 pub(crate) struct TableCtx {
     table: Packed<TableElem>,
-    rows: Vec<Vec<Option<(Packed<TableCell>, Tag, Vec<TagNode>)>>>,
+    rows: Vec<Vec<GridCell>>,
+}
+
+#[derive(Clone, Default)]
+enum GridCell {
+    Cell(TableCtxCell),
+    Spanned(usize, usize),
+    #[default]
+    Missing,
+}
+
+impl GridCell {
+    fn as_cell(&self) -> Option<&TableCtxCell> {
+        if let Self::Cell(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    fn into_cell(self) -> Option<TableCtxCell> {
+        if let Self::Cell(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Clone)]
+struct TableCtxCell {
+    rowspan: NonZeroUsize,
+    colspan: NonZeroUsize,
+    kind: TableCellKind,
+    header_scope: Smart<TableHeaderScope>,
+    nodes: Vec<TagNode>,
 }
 
 impl TableCtx {
@@ -136,71 +172,126 @@ impl TableCtx {
     fn insert(&mut self, cell: Packed<TableCell>, nodes: Vec<TagNode>) {
         let x = cell.x(StyleChain::default()).unwrap_or_else(|| unreachable!());
         let y = cell.y(StyleChain::default()).unwrap_or_else(|| unreachable!());
-        let rowspan = cell.rowspan(StyleChain::default()).get();
+        let rowspan = cell.rowspan(StyleChain::default());
-        let colspan = cell.colspan(StyleChain::default()).get();
+        let colspan = cell.colspan(StyleChain::default());
-
+        let kind = cell.kind(StyleChain::default());
-        // TODO: possibly set internal field on TableCell when resolving
-        // the cell grid.
         let header_scope = cell.header_scope(StyleChain::default());
-        let span = TableCellSpan { rows: rowspan as i32, cols: colspan as i32 };
+
-        let tag = if let Smart::Custom(scope) = header_scope {
+        // The explicit cell kind takes precedence, but if it is `auto` and a
-            let scope = match scope {
+        // scope was specified, make this a header cell.
-                TableHeaderScope::Both => krilla::tagging::TableHeaderScope::Both,
+        let kind = match (kind, header_scope) {
-                TableHeaderScope::Column => krilla::tagging::TableHeaderScope::Column,
+            (Smart::Custom(kind), _) => kind,
-                TableHeaderScope::Row => krilla::tagging::TableHeaderScope::Row,
+            (Smart::Auto, Smart::Custom(_)) => TableCellKind::Header,
-            };
+            (Smart::Auto, Smart::Auto) => TableCellKind::Data,
-            TagKind::TH(TableHeaderCell::new(scope).with_span(span))
-        } else {
-            TagKind::TD(TableDataCell::new().with_span(span))
         };
 
-        let required_height = y + rowspan;
+        // Extend the table grid to fit this cell.
+        let required_height = y + rowspan.get();
+        let required_width = x + colspan.get();
         if self.rows.len() < required_height {
-            self.rows.resize_with(required_height, Vec::new);
+            self.rows
+                .resize(required_height, vec![GridCell::Missing; required_width]);
         }
-
-        let required_width = x + colspan;
         let row = &mut self.rows[y];
         if row.len() < required_width {
-            row.resize_with(required_width, || None);
+            row.resize_with(required_width, || GridCell::Missing);
         }
 
-        row[x] = Some((cell, tag.into(), nodes));
+        // Store references to the cell for all spanned cells.
+        for i in y..y + rowspan.get() {
+            for j in x..x + colspan.get() {
+                self.rows[i][j] = GridCell::Spanned(x, y);
+            }
+        }
+
+        self.rows[y][x] =
+            GridCell::Cell(TableCtxCell { rowspan, colspan, kind, header_scope, nodes });
     }
 
     fn build_table(self, mut nodes: Vec<TagNode>) -> Vec<TagNode> {
         // Table layouting ensures that there are no overlapping cells, and that
         // any gaps left by the user are filled with empty cells.
+
+        // Only generate row groups such as `THead`, `TFoot`, and `TBody` if
+        // there are no rows with mixed cell kinds.
+        let mut mixed_row_kinds = false;
+        let row_kinds = (self.rows.iter())
+            .map(|row| {
+                row.iter()
+                    .filter_map(|cell| match cell {
+                        GridCell::Cell(cell) => Some(cell),
+                        &GridCell::Spanned(x, y) => self.rows[y][x].as_cell(),
+                        GridCell::Missing => None,
+                    })
+                    .map(|cell| cell.kind)
+                    .reduce(|a, b| {
+                        if a != b {
+                            mixed_row_kinds = true;
+                        }
+                        a
+                    })
+                    .expect("tables must have at least one column")
+            })
+            .collect::<Vec<_>>();
+
+        let Some(mut chunk_kind) = row_kinds.first().copied() else {
+            return nodes;
+        };
         let mut row_chunk = Vec::new();
-        let mut is_header_chunk = false;
+        for (row, row_kind) in self.rows.into_iter().zip(row_kinds) {
-        for row in self.rows.into_iter() {
-            let mut is_header_row = true;
             let row_nodes = row
                 .into_iter()
-                .flatten()
+                .filter_map(|cell| {
-                .map(|(cell, tag, nodes)| {
+                    let cell = cell.into_cell()?;
-                    is_header_row &= cell.header_scope(StyleChain::default()).is_custom();
+                    let span = TableCellSpan {
-                    TagNode::Group(tag, nodes)
+                        rows: cell.rowspan.get() as i32,
+                        cols: cell.colspan.get() as i32,
+                    };
+                    let tag = match cell.kind {
+                        TableCellKind::Header => {
+                            let scope = match cell.header_scope {
+                                Smart::Custom(scope) => table_header_scope(scope),
+                                Smart::Auto => krilla::tagging::TableHeaderScope::Column,
+                            };
+                            TagKind::TH(TableHeaderCell::new(scope).with_span(span))
+                        }
+                        TableCellKind::Footer | TableCellKind::Data => {
+                            TagKind::TD(TableDataCell::new().with_span(span))
+                        }
+                    };
+
+                    Some(TagNode::Group(tag.into(), cell.nodes))
                 })
                 .collect();
 
             let row = TagNode::Group(TagKind::TR.into(), row_nodes);
-            if row_chunk.is_empty() {
+
-                is_header_chunk = is_header_row;
+            // Push the `TR` tags directly.
-                row_chunk.push(row);
+            if mixed_row_kinds {
-            } else if is_header_chunk == is_header_row {
+                nodes.push(row);
-                row_chunk.push(row);
+                continue;
-            } else {
+            }
-                let tag = if is_header_chunk { TagKind::THead } else { TagKind::TBody };
+
+            // Generate row groups.
+            if row_kind != chunk_kind {
+                let tag = match chunk_kind {
+                    TableCellKind::Header => TagKind::THead,
+                    TableCellKind::Footer => TagKind::TFoot,
+                    TableCellKind::Data => TagKind::TBody,
+                };
                 nodes.push(TagNode::Group(tag.into(), std::mem::take(&mut row_chunk)));
 
-                is_header_chunk = is_header_row;
+                chunk_kind = row_kind;
-                row_chunk.push(row);
             }
+            row_chunk.push(row);
         }
 
         if !row_chunk.is_empty() {
-            let tag = if is_header_chunk { TagKind::THead } else { TagKind::TBody };
+            let tag = match chunk_kind {
+                TableCellKind::Header => TagKind::THead,
+                TableCellKind::Footer => TagKind::TFoot,
+                TableCellKind::Data => TagKind::TBody,
+            };
             nodes.push(TagNode::Group(tag.into(), row_chunk));
         }
 
@@ -208,6 +299,7 @@ impl TableCtx {
     }
 }
 
+#[derive(Clone)]
 pub(crate) enum TagNode {
     Group(Tag, Vec<TagNode>),
     Leaf(Identifier),
@@ -399,17 +491,9 @@ pub(crate) fn handle_start(gc: &mut GlobalContext, elem: &Content) {
             _ => todo!(),
         }
     } else if let Some(heading) = elem.to_packed::<HeadingElem>() {
-        let level = heading.level();
+        let level = heading.level().try_into().unwrap_or(NonZeroU32::MAX);
         let name = heading.body.plain_text().to_string();
-        match level.get() {
+        TagKind::Hn(level, Some(name)).into()
-            1 => TagKind::H1(Some(name)).into(),
-            2 => TagKind::H2(Some(name)).into(),
-            3 => TagKind::H3(Some(name)).into(),
-            4 => TagKind::H4(Some(name)).into(),
-            5 => TagKind::H5(Some(name)).into(),
-            // TODO: when targeting PDF 2.0 headings `> 6` are supported
-            _ => TagKind::H6(Some(name)).into(),
-        }
     } else if let Some(_) = elem.to_packed::<OutlineBody>() {
         push_stack(gc, loc, StackEntryKind::Outline(OutlineCtx::new()));
         return;
@@ -523,6 +607,14 @@ fn start_artifact(gc: &mut GlobalContext, loc: Location, kind: ArtifactKind) {
     gc.tags.in_artifact = Some((loc, kind));
 }
 
+fn table_header_scope(scope: TableHeaderScope) -> krilla::tagging::TableHeaderScope {
+    match scope {
+        TableHeaderScope::Both => krilla::tagging::TableHeaderScope::Both,
+        TableHeaderScope::Column => krilla::tagging::TableHeaderScope::Column,
+        TableHeaderScope::Row => krilla::tagging::TableHeaderScope::Row,
+    }
+}
+
 fn artifact_type(kind: ArtifactKind) -> ArtifactType {
     match kind {
         ArtifactKind::Header => ArtifactType::Header,

crates/typst-pdf/src/text.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 
 use bytemuck::TransparentWrapper;
 use krilla::surface::{Location, Surface};
+use krilla::tagging::SpanTag;
 use krilla::text::GlyphId;
 use typst_library::diag::{bail, SourceResult};
 use typst_library::layout::Size;
@@ -23,7 +24,8 @@ pub(crate) fn handle_text(
 ) -> SourceResult<()> {
     *gc.languages.entry(t.lang).or_insert(0) += t.glyphs.len();
 
-    let mut handle = tags::start_marked(gc, surface);
+    let mut handle =
+        tags::start_span(gc, surface, SpanTag::empty().with_actual_text(Some(&t.text)));
     let surface = handle.surface();
 
     let font = convert_font(gc, t.font.clone())?;

crates/typst-realize/src/lib.rs

@@ -18,7 +18,7 @@ use typst_library::foundations::{
     SequenceElem, Show, ShowSet, Style, StyleChain, StyledElem, Styles, SymbolElem,
     Synthesize, Transformation,
 };
-use typst_library::html::{tag, HtmlElem};
+use typst_library::html::{tag, FrameElem, HtmlElem};
 use typst_library::introspection::{Locatable, SplitLocator, Tag, TagElem};
 use typst_library::layout::{
     AlignElem, BoxElem, HElem, InlineElem, PageElem, PagebreakElem, VElem,
@@ -237,9 +237,9 @@ fn visit<'a>(
         return Ok(());
     }
 
-    // Transformations for math content based on the realization kind. Needs
+    // Transformations for content based on the realization kind. Needs
     // to happen before show rules.
-    if visit_math_rules(s, content, styles)? {
+    if visit_kind_rules(s, content, styles)? {
         return Ok(());
     }
 
@@ -280,9 +280,8 @@ fn visit<'a>(
     Ok(())
 }
 
-// Handles special cases for math in normal content and nested equations in
+// Handles transformations based on the realization kind.
-// math.
+fn visit_kind_rules<'a>(
-fn visit_math_rules<'a>(
     s: &mut State<'a, '_, '_, '_>,
     content: &'a Content,
     styles: StyleChain<'a>,
@@ -335,6 +334,13 @@ fn visit_math_rules<'a>(
         }
     }
 
+    if !s.kind.is_html() {
+        if let Some(elem) = content.to_packed::<FrameElem>() {
+            visit(s, &elem.body, styles)?;
+            return Ok(true);
+        }
+    }
+
     Ok(false)
 }
 

crates/typst-syntax/src/ast.rs

@@ -724,6 +724,8 @@ node! {
 
 impl<'a> Ref<'a> {
     /// Get the target.
+    ///
+    /// Will not be empty.
     pub fn target(self) -> &'a str {
         self.0
             .children()

crates/typst-syntax/src/lexer.rs

@@ -185,7 +185,7 @@ impl Lexer<'_> {
             'h' if self.s.eat_if("ttp://") => self.link(),
             'h' if self.s.eat_if("ttps://") => self.link(),
             '<' if self.s.at(is_id_continue) => self.label(),
-            '@' => self.ref_marker(),
+            '@' if self.s.at(is_id_continue) => self.ref_marker(),
 
             '.' if self.s.eat_if("..") => SyntaxKind::Shorthand,
             '-' if self.s.eat_if("--") => SyntaxKind::Shorthand,

docs/guides/guide-for-latex-users.md

@@ -256,8 +256,8 @@ In Typst, the same function can be used both to affect the appearance for the
 remainder of the document, a block (or scope), or just its arguments. For
 example, `[#text(weight: "bold")[bold text]]` will only embolden its argument,
 while `[#set text(weight: "bold")]` will embolden any text until the end of the
-current block, or, if there is none, document. The effects of a function are
+current block, or the end of the document, if there is none. The effects of a
-immediately obvious based on whether it is used in a call or a
+function are immediately obvious based on whether it is used in a call or a
 [set rule.]($styling/#set-rules)
 
 ```example

docs/guides/page-setup.md

@@ -206,7 +206,6 @@ label exists on the current page:
 ```typ
 >>> #set page("a5", margin: (x: 2.5cm, y: 3cm))
 #set page(header: context {
-  let page-counter =
   let matches = query(<big-table>)
   let current = counter(page).get()
   let has-table = matches.any(m =>
@@ -218,7 +217,7 @@ label exists on the current page:
     #h(1fr)
     National Academy of Sciences
   ]
-}))
+})
 
 #lorem(100)
 #pagebreak()

docs/reference/groups.yml

@@ -181,11 +181,7 @@
     [`sys.version`]($category/foundations/sys) can also be very useful.
 
     ```typ
-    #let tiling = if "tiling" in dictionary(std) {
+    #let tiling = if "tiling" in std { tiling } else { pattern }
-      tiling
-    } else {
-      pattern
-    }
 
     ...
     ```

docs/src/lib.rs

@@ -720,18 +720,12 @@ fn symbols_model(resolver: &dyn Resolver, group: &GroupData) -> SymbolsModel {
             }
         };
 
-        for (variant, c) in symbol.variants() {
+        for (variant, c, deprecation) in symbol.variants() {
             let shorthand = |list: &[(&'static str, char)]| {
                 list.iter().copied().find(|&(_, x)| x == c).map(|(s, _)| s)
             };
 
             let name = complete(variant);
-            let deprecation = match name.as_str() {
-                "integral.sect" => {
-                    Some("`integral.sect` is deprecated, use `integral.inter` instead")
-                }
-                _ => binding.deprecation(),
-            };
 
             list.push(SymbolModel {
                 name,
@@ -742,10 +736,10 @@ fn symbols_model(resolver: &dyn Resolver, group: &GroupData) -> SymbolsModel {
                 accent: typst::math::Accent::combine(c).is_some(),
                 alternates: symbol
                     .variants()
-                    .filter(|(other, _)| other != &variant)
+                    .filter(|(other, _, _)| other != &variant)
-                    .map(|(other, _)| complete(other))
+                    .map(|(other, _, _)| complete(other))
                     .collect(),
-                deprecation,
+                deprecation: deprecation.or_else(|| binding.deprecation()),
             });
         }
     }

tests/ref/html/html-deco.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <p><s>Struck</s> <mark>Highlighted</mark> <span style="text-decoration: underline">Underlined</span> <span style="text-decoration: overline">Overlined</span></p>
+    <p><span style="text-decoration: overline"><span style="text-decoration: underline"><mark><s>Mixed</s></mark></span></span></p>
+  </body>
+</html>

tests/suite/foundations/label.typ

@@ -92,3 +92,7 @@ _Visible_
 --- label-non-existent-error ---
 // Error: 5-10 sequence does not have field "label"
 #[].label
+
+--- label-empty ---
+// Error: 23-32 label name must not be empty
+= Something to label #label("")

tests/suite/html/frame.typ

@@ -0,0 +1,8 @@
+// No proper HTML tests here yet because we don't want to test SVG export just
+// yet. We'll definitely add tests at some point.
+
+--- html-frame-in-layout ---
+// Ensure that HTML frames are transparent in layout. This is less important for
+// actual paged export than for _nested_ HTML frames, which take the same code
+// path.
+#html.frame[A]

tests/suite/layout/align.typ

@@ -34,7 +34,7 @@ To the right! Where the sunlight peeks behind the mountain.
 #align(start)[Start]
 #align(end)[Ende]
 
-#set text(lang: "ar")
+#set text(lang: "ar", font: "Noto Sans Arabic")
 #align(start)[يبدأ]
 #align(end)[نهاية]
 

tests/suite/layout/inline/bidi.typ

@@ -45,6 +45,7 @@ Lריווח #h(1cm) R
 
 --- bidi-whitespace-reset ---
 // Test whether L1 whitespace resetting destroys stuff.
+#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
 الغالب #h(70pt) ن#" "ة
 
 --- bidi-explicit-dir ---
@@ -87,7 +88,7 @@ Lריווח #h(1cm) R
   columns: (1fr, 1fr),
   lines(6),
   [
-    #text(lang: "ar")[مجرد نص مؤقت لأغراض العرض التوضيحي. ]
+    #text(lang: "ar", font: ("Libertinus Serif", "Noto Sans Arabic"))[مجرد نص مؤقت لأغراض العرض التوضيحي. ]
     #text(lang: "ar")[سلام]
   ],
 )

tests/suite/layout/inline/shaping.typ

@@ -29,6 +29,7 @@ ABCअपार्टमेंट
 \ ט
 
 --- shaping-font-fallback ---
+#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
 // Font fallback for emoji.
 A😀B
 

tests/suite/layout/inline/text.typ

@@ -80,7 +80,7 @@ I'm in#text(tracking: 0.15em + 1.5pt)[ spaace]!
 
 --- text-tracking-arabic ---
 // Test tracking in arabic text (makes no sense whatsoever)
-#set text(tracking: 0.3em)
+#set text(tracking: 0.3em, font: "Noto Sans Arabic")
 النص
 
 --- text-spacing ---

tests/suite/layout/repeat.typ

@@ -17,7 +17,7 @@
 
 --- repeat-dots-rtl ---
 // Test dots with RTL.
-#set text(lang: "ar")
+#set text(lang: "ar", font: ("Libertinus Serif", "Noto Sans Arabic"))
 مقدمة #box(width: 1fr, repeat[.]) 15
 
 --- repeat-empty ---
@@ -35,7 +35,7 @@ A#box(width: 1fr, repeat(rect(width: 6em, height: 0.7em)))B
 #set align(center)
 A#box(width: 1fr, repeat(rect(width: 6em, height: 0.7em)))B
 
-#set text(dir: rtl)
+#set text(dir: rtl, font: "Noto Sans Arabic")
 ريجين#box(width: 1fr, repeat(rect(width: 4em, height: 0.7em)))سون
 
 --- repeat-unrestricted ---

tests/suite/math/attach.typ

@@ -121,8 +121,8 @@ $a scripts(=)^"def" b quad a scripts(lt.eq)_"really" b quad a scripts(arrow.r.lo
 
 --- math-attach-integral ---
 // Test default of scripts attachments on integrals at display size.
-$ integral.sect_a^b  quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b $
+$ integral.inter_a^b  quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b $
-$integral.sect_a^b quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b$
+$integral.inter_a^b quad \u{2a1b}_a^b quad limits(\u{2a1b})_a^b$
 
 --- math-attach-large-operator ---
 // Test default of limit attachments on large operators at display size only.
@@ -179,7 +179,7 @@ $ a0 + a1 + a0_2 \
 #{
   let var = $x^1$
   for i in range(24) {
-    var = $var$    
+    var = $var$
   }
   $var_2$
 }

tests/suite/model/bibliography.typ

@@ -75,6 +75,14 @@ Now we have multiple bibliographies containing @glacier-melt @keshav2007read
 // Error: 2-62 CSL style "Alphanumeric" is not suitable for bibliographies
 #bibliography("/assets/bib/works.bib", style: "alphanumeric")
 
+--- bibliography-empty-key ---
+#let src = ```yaml
+"":
+  type: Book
+```
+// Error: 15-30 bibliography contains entry with empty key
+#bibliography(bytes(src.text))
+
 --- issue-4618-bibliography-set-heading-level ---
 // Test that the bibliography block's heading is set to 2 by the show rule,
 // and therefore should be rendered like a level-2 heading. Notably, this

tests/suite/model/cite.typ

@@ -147,3 +147,16 @@ B #cite(<netwok>) #cite(<arrgh>).
 // Error: 7-17 expected label, found string
 // Hint: 7-17 use `label("%@&#*!\\")` to create a label
 #cite("%@&#*!\\")
+
+--- issue-5775-cite-order-rtl ---
+// Test citation order in RTL text.
+#set page(width: 300pt)
+#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
+@netwok
+aaa
+این است
+@tolkien54
+و این یکی هست
+@arrgh
+
+#bibliography("/assets/bib/works.bib")

tests/suite/model/par.typ

@@ -231,7 +231,7 @@ Welcome \ here. Does this work well?
 
 --- par-hanging-indent-rtl ---
 #set par(hanging-indent: 2em)
-#set text(dir: rtl)
+#set text(dir: rtl, font: ("Libertinus Serif", "Noto Sans Arabic"))
 لآن وقد أظلم الليل وبدأت النجوم
 تنضخ وجه الطبيعة التي أعْيَتْ من طول ما انبعثت في النهار
 

tests/suite/model/quote.typ

@@ -2,6 +2,7 @@
 
 --- quote-dir-author-pos ---
 // Text direction affects author positioning
+#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
 And I quote: #quote(attribution: [René Descartes])[cogito, ergo sum].
 
 #set text(lang: "ar")
@@ -9,6 +10,7 @@ And I quote: #quote(attribution: [René Descartes])[cogito, ergo sum].
 
 --- quote-dir-align ---
 // Text direction affects block alignment
+#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
 #set quote(block: true)
 #quote(attribution: [René Descartes])[cogito, ergo sum]
 

tests/suite/model/ref.typ

@@ -86,3 +86,14 @@ Text seen on #ref(<text>, form: "page", supplement: "Page").
 // Test reference with non-whitespace before it.
 #figure[] <1>
 #test([(#ref(<1>))], [(@1)])
+
+--- ref-to-empty-label-not-possible ---
+// @ without any following label should just produce the symbol in the output
+// and not produce a reference to a label with an empty name.
+@
+
+--- ref-function-empty-label ---
+// using ref() should also not be possible
+// Error: 6-7 unexpected less-than operator
+// Error: 7-8 unexpected greater-than operator
+#ref(<>)

tests/suite/scripting/ops.typ

@@ -264,6 +264,8 @@
 #test("Hey" not in "abheyCd", true)
 #test("a" not
 /* fun comment? */ in "abc", false)
+#test("sys" in std, true)
+#test("system" in std, false)
 
 --- ops-not-trailing ---
 // Error: 10 expected keyword `in`

tests/suite/syntax/numbers.typ

@@ -2,6 +2,7 @@
 
 --- numbers ---
 // Test numbers in text mode.
+#set text(font: ("Libertinus Serif", "Noto Sans Arabic"))
 12 \
 12.0 \
 3.14 \

tests/suite/text/deco.typ

@@ -83,3 +83,11 @@ We can also specify a customized value
 #highlight(stroke: 2pt + blue)[abc]
 #highlight(stroke: (top: blue, left: red, bottom: green, right: orange))[abc]
 #highlight(stroke: 1pt, radius: 3pt)[#lorem(5)]
+
+--- html-deco html ---
+#strike[Struck]
+#highlight[Highlighted]
+#underline[Underlined]
+#overline[Overlined]
+
+#(strike, highlight, underline, overline).fold([Mixed], (it, f) => f(it))

tests/suite/visualize/gradient.typ

@@ -666,3 +666,29 @@ $ A = mat(
 #let _ = gradient.linear(..my-gradient.stops())
 #let my-gradient2 = gradient.linear(red, blue).repeat(5, mirror: true)
 #let _ = gradient.linear(..my-gradient2.stops())
+
+--- issue-6162-coincident-gradient-stops-export-png ---
+// Ensure that multiple gradient stops with the same position
+// don't cause a panic.
+#rect(
+  fill: gradient.linear(
+    (red, 0%),
+    (green, 0%),
+    (blue, 100%),
+  )
+)
+#rect(
+  fill: gradient.linear(
+    (red, 0%),
+    (green, 100%),
+    (blue, 100%),
+  )
+)
+#rect(
+  fill: gradient.linear(
+    (white, 0%),
+    (red, 50%),
+    (green, 50%),
+    (blue, 100%),
+  )
+)